Support jsonp by storing the value of the callback parameter in $uploadprogress_callback.

Added an 'upload_progress_jsonp_output' directive that sets templates that work with jsonp.
Make jsonp parameter name configurable with the 'upload_progress_jsonp_parameter' directive.

README

     :Description:
     This directive allows to change the header name of the progress ID.
 
+upload_progress_jsonp_parameter
+++++++++++++++++++++++
+    :Syntax: upload_progress_jsonp_parameter <callback_parameter>
+    :Default: callback
+    :Context: location
+    :Description:
+    This directive allows to change the name of the GET parameter with the jsonp callback name.
+
 upload_progress_json_output
 +++++++++++++++++++++++++++
     :Syntax: upload_progress_json_output
     :Description:
     This directive sets everything to output as pure json.
 
+upload_progress_jsonp_output
++++++++++++++++++++++++++++
+    :Syntax: upload_progress_jsonp_output
+    :Default: N/A
+    :Context: location
+    :Description:
+    This directive sets everything to output as jsonp (like json output, but with callback).
+
 upload_progress_template
 ++++++++++++++++++++++++
     :Syntax: upload_progress_template <state> <template>
         * $uploadprogress_length: total size of the upload
         * $uploadprogress_received: what the server has received so far
         * $uploadprogress_status: error code in case of HTTP error
+        * $uploadprogress_callback: jsonp callback name if provided as a GET query parameter with name 'callback'
     
     For instance to return XML (instead of the default Javascript or json):
 
     upload_progress_template done '<upload><state>done</state></upload>';
     upload_progress_template error '<upload><state>error</state><code>$uploadprogress_status</code></upload>';
 
+    Example of jsonp response:
+
+    upload_progress_template starting "$uploadprogress_callback({ 'state' : 'starting'});";
+    upload_progress_template error "$uploadprogress_callback({ 'state' : 'error', 'status' : $uploadprogress_status });";
+    upload_progress_template done "$uploadprogress_callback({ 'state' : 'done'});";
+    upload_progress_template uploading "$uploadprogress_callback({ 'state' : 'uploading', 'received' : $uploadprogress_received, 'size' : $uploadprogress_length });";
 
 Configuration Example:
 +++++++++++++++++++++

ngx_http_uploadprogress_module.c

     ngx_str_t                        content_type;
     ngx_array_t                      templates;
     ngx_str_t                        header;
+    ngx_str_t                        jsonp_parameter;
 } ngx_http_uploadprogress_conf_t;
 
 typedef struct {
     ngx_http_variable_value_t *v, uintptr_t data);
 static ngx_int_t ngx_http_uploadprogress_status_variable(ngx_http_request_t *r,
     ngx_http_variable_value_t *v, uintptr_t data);
+static ngx_int_t ngx_http_uploadprogress_callback_variable(ngx_http_request_t *r,
+    ngx_http_variable_value_t *v, uintptr_t data);
 static char* ngx_http_upload_progress_set_template(ngx_conf_t * cf, ngx_http_uploadprogress_template_t *t, ngx_str_t *source);
 static char *ngx_http_track_uploads(ngx_conf_t * cf, ngx_command_t * cmd, void *conf);
 static char *ngx_http_report_uploads(ngx_conf_t * cf, ngx_command_t * cmd, void *conf);
 static char *ngx_http_upload_progress(ngx_conf_t * cf, ngx_command_t * cmd, void *conf);
 static char* ngx_http_upload_progress_template(ngx_conf_t * cf, ngx_command_t * cmd, void *conf);
 static char* ngx_http_upload_progress_json_output(ngx_conf_t * cf, ngx_command_t * cmd, void *conf);
+static char* ngx_http_upload_progress_jsonp_output(ngx_conf_t * cf, ngx_command_t * cmd, void *conf);
 static void ngx_clean_old_connections(ngx_event_t * ev);
 static ngx_int_t ngx_http_uploadprogress_content_handler(ngx_http_request_t *r);
 
      0,
      NULL},
 
+    {ngx_string("upload_progress_jsonp_output"),
+     NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF | NGX_CONF_NOARGS,
+     ngx_http_upload_progress_jsonp_output,
+     NGX_HTTP_LOC_CONF_OFFSET,
+     0,
+     NULL},
+
     {ngx_string("upload_progress_header"),
      NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF | NGX_CONF_TAKE1,
      ngx_conf_set_str_slot,
      offsetof(ngx_http_uploadprogress_conf_t, header),
      NULL},
 
+    {ngx_string("upload_progress_jsonp_parameter"),
+     NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF | NGX_CONF_TAKE1,
+     ngx_conf_set_str_slot,
+     NGX_HTTP_LOC_CONF_OFFSET,
+     offsetof(ngx_http_uploadprogress_conf_t, jsonp_parameter),
+     NULL},
+
     ngx_null_command
 };
 
       (uintptr_t) offsetof(ngx_http_uploadprogress_node_t, err_status),
       NGX_HTTP_VAR_CHANGEABLE|NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_NOHASH, 0 },
 
+    { ngx_string("uploadprogress_callback"), NULL, ngx_http_uploadprogress_callback_variable,
+      (uintptr_t) NULL,
+      NGX_HTTP_VAR_CHANGEABLE|NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_NOHASH, 0 },
+
     { ngx_null_string, NULL, NULL, 0, 0, 0 }
 };
 
     ngx_string("{ \"state\" : \"uploading\", \"received\" : $uploadprogress_received, \"size\" : $uploadprogress_length }\r\n")
 };
 
+static ngx_str_t ngx_http_uploadprogress_jsonp_defaults[] = {
+    ngx_string("$uploadprogress_callback({ \"state\" : \"starting\" });\r\n"),
+    ngx_string("$uploadprogress_callback({ \"state\" : \"error\", \"status\" : $uploadprogress_status });\r\n"),
+    ngx_string("$uploadprogress_callback({ \"state\" : \"done\" });\r\n"),
+    ngx_string("$uploadprogress_callback({ \"state\" : \"uploading\", \"received\" : $uploadprogress_received, \"size\" : $uploadprogress_length });\r\n")
+};
+
+
 static ngx_array_t ngx_http_uploadprogress_global_templates;
 
 static ngx_str_t*
     } 
 
     ngx_conf_merge_str_value(conf->header, prev->header, "X-Progress-ID");
+    ngx_conf_merge_str_value(conf->jsonp_parameter, prev->jsonp_parameter, "callback");
 
     return NGX_CONF_OK;
 }
     return NGX_CONF_OK;
 }
 
+static char*
+ngx_http_upload_progress_jsonp_output(ngx_conf_t * cf, ngx_command_t * cmd, void *conf)
+{
+    ngx_http_uploadprogress_conf_t       *upcf = conf;
+    ngx_http_uploadprogress_template_t   *t;
+    ngx_uint_t                            i;
+    char*                                 rc;
+
+    t = (ngx_http_uploadprogress_template_t*)upcf->templates.elts;
+
+    for(i = 0;i < upcf->templates.nelts;i++) {
+        rc = ngx_http_upload_progress_set_template(cf, t + i, ngx_http_uploadprogress_jsonp_defaults + i);
+
+        if(rc != NGX_CONF_OK) {
+            return rc;
+        }
+    }
+
+    upcf->content_type.data = (u_char*)"application/javascript";
+    upcf->content_type.len = sizeof("application/javascript") - 1;
+
+    return NGX_CONF_OK;
+}
+
 static ngx_int_t ngx_http_uploadprogress_received_variable(ngx_http_request_t *r,
     ngx_http_variable_value_t *v, uintptr_t data)
 {
     return NGX_OK;
 }
 
+static ngx_int_t
+ngx_http_uploadprogress_callback_variable(ngx_http_request_t *r,
+    ngx_http_variable_value_t *v,  uintptr_t data)
+{
+    u_char                          *p, *start_p, *val, prefix[1024];
+    ngx_http_uploadprogress_conf_t  *upcf;
+    u_int                            len;
+
+    upcf = ngx_http_get_module_loc_conf(r, ngx_http_uploadprogress_module);
+
+    if (r->args.len) {
+        /* '=' has to be appended to avoid matching parameters that have the */
+        /* configured name as a prefix but are longer */
+        ngx_snprintf(prefix, sizeof(prefix) - 1, "%s=", upcf->jsonp_parameter.data);
+        len = upcf->jsonp_parameter.len + 1;
+        prefix[len] = '\0'; /* Force termination of string */
+
+        p = (u_char *) ngx_strstr(r->args.data, prefix);
+
+        if (p) {
+            p += len;
+            start_p = p;
+            while (p < r->args.data + r->args.len) {
+                if (*((p++) + 1) == '&') {
+                    break;
+                }
+            }
+
+            v->len = p - start_p;
+
+            val = ngx_palloc(r->pool, v->len + 1);
+            if (val == NULL) {
+                return NGX_ERROR;
+            }
+
+            ngx_memcpy(val, start_p, v->len);
+            val[v->len] = '\0';
+
+            v->valid = 1;
+            v->no_cacheable = 0;
+            v->not_found = 0;
+            v->data = val;
+        } else {
+            return NGX_ERROR;
+        }
+    } else {
+        return NGX_ERROR;
+    }
+
+    return NGX_OK;
+}
+
+