自学教程：C++ uwsgi_str函数代码示例

struct zergpool_socket *add_zergpool_socket(char *name, char *sockets) {	struct zergpool_socket *z_sock,*zps = zergpool_sockets;	if (!zps) {		z_sock = uwsgi_calloc(sizeof(struct zergpool_socket));		zergpool_sockets = z_sock;	}	else {		while(zps) {			if (!zps->next) {				z_sock= uwsgi_calloc(sizeof(struct zergpool_socket));				zps->next = z_sock;				break;			}			zps = zps->next;		}	}	// do not defer accept for zergpools	if (uwsgi.no_defer_accept) {		uwsgi.no_defer_accept = 0;		z_sock->fd = bind_to_unix(name, uwsgi.listen_queue, uwsgi.chmod_socket, 0);		uwsgi.no_defer_accept = 1;	}	else {		z_sock->fd = bind_to_unix(name, uwsgi.listen_queue, uwsgi.chmod_socket, 0);	}	char *sock_list = uwsgi_str(sockets);	char *p = strtok(sock_list, ",");	while(p) {		z_sock->num_sockets++;		p = strtok(NULL, ",");	}	free(sock_list);	z_sock->sockets = uwsgi_calloc(sizeof(int) * (z_sock->num_sockets + 1));	sock_list = uwsgi_str(sockets);	int pos = 0;	p = strtok(sock_list, ",");	while(p) {		char *port = strchr(p, ':');		if (!port) {			z_sock->sockets[pos] = bind_to_unix(p, uwsgi.listen_queue, uwsgi.chmod_socket, uwsgi.abstract_socket);			uwsgi_log("zergpool %s bound to UNIX socket %s (fd: %d)/n", name, uwsgi_getsockname(z_sock->sockets[pos]), z_sock->sockets[pos]);		}		else {			char *gsn = generate_socket_name(p);			z_sock->sockets[pos] = bind_to_tcp(gsn, uwsgi.listen_queue, strchr(gsn, ':'));			uwsgi_log("zergpool %s bound to TCP socket %s (fd: %d)/n", name, uwsgi_getsockname(z_sock->sockets[pos]), z_sock->sockets[pos]);		}		pos++;		p = strtok(NULL, ",");	}	return z_sock;}

// initialize alarms, instances and log regexpsvoid uwsgi_alarms_init() {	// first of all, create instance of alarms	struct uwsgi_string_list *usl = uwsgi.alarm_list;	while(usl) {		char *line = uwsgi_str(usl->value);		char *space = strchr(line, ' ');		if (!space) {			uwsgi_log("invalid alarm syntax: %s/n", usl->value);			exit(1);		}		*space = 0;		char *plugin = space+1;		char *colon = strchr(plugin, ':');		if (!colon) {			uwsgi_log("invalid alarm syntax: %s/n", usl->value);			exit(1);		}		*colon = 0;		char *arg = colon+1;		// here the alarm is mapped to a name and initialized		if (uwsgi_alarm_add(line, plugin, arg)) {			uwsgi_log("invalid alarm: %s/n", usl->value);			exit(1);		}		usl = usl->next;	}	// then map log-alarm	usl = uwsgi.alarm_logs_list;	while(usl) {		char *line = uwsgi_str(usl->value);		char *space = strchr(line, ' ');                if (!space) {                        uwsgi_log("invalid log-alarm syntax: %s/n", usl->value);                        exit(1);                }                *space = 0;                char *regexp = space+1;                // here the log-alarm is created                if (uwsgi_alarm_log_add(line, regexp)) {                        uwsgi_log("invalid log-alarm: %s/n", usl->value);                        exit(1);                }		usl = usl->next;	}}

void uwsgi_opt_add_route(char *opt, char *value, void *foobar) {	char *route = uwsgi_str(value);	char *space = strchr(route, ' ');	if (!space) {		uwsgi_log("invalid route syntax/n");		exit(1);	}	*space = 0;	struct uwsgi_route *ur = uwsgi.routes;	if (!ur) {		uwsgi.routes = uwsgi_calloc(sizeof(struct uwsgi_route));		ur = uwsgi.routes;	}	else {		while (ur) {			if (!ur->next) {				ur->next = uwsgi_calloc(sizeof(struct uwsgi_route));				ur = ur->next;				break;			}			ur = ur->next;		}	}	if (!strcmp(foobar, "http_host")) {		ur->subject = offsetof(struct wsgi_request, host);		ur->subject_len = offsetof(struct wsgi_request, host_len);	}

void uwsgi_autoload_plugins_by_name(char *argv_zero) {	char *plugins_requested = NULL;	char *original_proc_name = getenv("UWSGI_ORIGINAL_PROC_NAME");	if (!original_proc_name) {		// here we use argv[0];		original_proc_name = argv_zero;		setenv("UWSGI_ORIGINAL_PROC_NAME", original_proc_name, 1);	}	char *p = strrchr(original_proc_name, '/');	if (p == NULL)		p = original_proc_name;	p = strstr(p, "uwsgi_");	if (p != NULL) {		plugins_requested = strtok(uwsgi_str(p + 6), "_");		while (plugins_requested) {			uwsgi_log("[uwsgi] implicit plugin requested %s/n", plugins_requested);			uwsgi_load_plugin(-1, plugins_requested, NULL);			plugins_requested = strtok(NULL, "_");		}	}	plugins_requested = getenv("UWSGI_PLUGINS");	if (plugins_requested) {		plugins_requested = uwsgi_concat2(plugins_requested, "");		char *p = strtok(plugins_requested, ",");		while (p != NULL) {			uwsgi_load_plugin(-1, p, NULL);			p = strtok(NULL, ",");		}	}}

void uwsgi_emperor_simple_do(struct uwsgi_emperor_scanner *ues, char *name, char *config, time_t ts, uid_t uid, gid_t gid) {	if (!uwsgi_emperor_is_valid(name))		return;	struct uwsgi_instance *ui_current = emperor_get(name);	if (ui_current) {		// check if uid or gid are changed, in such case, stop the instance		if (uwsgi.emperor_tyrant) {			if (uid != ui_current->uid || gid != ui_current->gid) {				uwsgi_log("[emperor-tyrant] !!! permissions of vassal %s changed. stopping the instance... !!!/n", name);				emperor_stop(ui_current);				return;			}		}		// check if mtime is changed and the uWSGI instance must be reloaded		if (ts > ui_current->last_mod) {			// make a new config (free the old one)			free(ui_current->config);			ui_current->config = config;			ui_current->config_len = strlen(config);			// always respawn (no need for amqp-style rules)			emperor_respawn(ui_current, ts);		}	}	else {		// make a copy of the config as it will be freed		emperor_add(ues, name, ts, uwsgi_str(config), strlen((const char *) config), uid, gid);	}}

static int uwsgi_jwsgi_setup() {	char *app = uwsgi_str(ujwsgi.app);	char *method = "application";	char *colon = strchr(app, ':');	if (colon) {		*colon = 0;		method = colon + 1;	}	ujwsgi.app_class = uwsgi_jvm_class(app);	if (!ujwsgi.app_class) {		exit(1);	}	ujwsgi.app_mid = uwsgi_jvm_get_static_method_id_quiet(ujwsgi.app_class, method, "(Ljava/util/HashMap;)[Ljava/lang/Object;");	if (uwsgi_jvm_exception() || !ujwsgi.app_mid) {                jmethodID mid = uwsgi_jvm_get_method_id(ujwsgi.app_class, "<init>", "()V");                if (uwsgi_jvm_exception() || !mid) exit(1);        	ujwsgi.app_instance = (*ujvm_env)->NewObject(ujvm_env, ujwsgi.app_class, mid);        	if (uwsgi_jvm_exception() || !ujwsgi.app_instance) {			exit(1);        	}		ujwsgi.app_mid = uwsgi_jvm_get_method_id(ujwsgi.app_class, method, "(Ljava/util/HashMap;)[Ljava/lang/Object;");        	if (uwsgi_jvm_exception() || !ujwsgi.app_mid) {			exit(1);        	}	}	uwsgi_log("JWSGI app /"%s/" loaded/n", ujwsgi.app);	return 0;}

static void uwsgi_alarm_curl_loop(struct uwsgi_thread *ut) {	int interesting_fd;	ut->buf = uwsgi_malloc(uwsgi.log_master_bufsize);	CURL *curl = curl_easy_init();	// ARGH !!!	if (!curl) return;	curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT]);	curl_easy_setopt(curl, CURLOPT_TIMEOUT, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT]);	curl_easy_setopt(curl, CURLOPT_READFUNCTION, uwsgi_alarm_curl_read_callback);	curl_easy_setopt(curl, CURLOPT_READDATA, ut);	curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);	curl_easy_setopt(curl, CURLOPT_POST, 1L);	struct curl_slist *expect = NULL; expect = curl_slist_append(expect, "Expect:");	curl_easy_setopt(curl, CURLOPT_HTTPHEADER, expect);	struct uwsgi_alarm_curl_config *uacc = (struct uwsgi_alarm_curl_config *) ut->data;	char *opts = uwsgi_str(uacc->arg);	// fill curl options	char *ctx = NULL;	char *p = strtok_r(opts, ";", &ctx);	while(p) {		uwsgi_alarm_curl_setopt(curl, uwsgi_str(p), uacc);		p = strtok_r(NULL, ";", &ctx);	}	for(;;) {		int ret = event_queue_wait(ut->queue, -1, &interesting_fd);			if (ret < 0) return;		if (ret == 0) continue;		if (interesting_fd != ut->pipe[1]) continue;		ssize_t rlen = read(ut->pipe[1], ut->buf, uwsgi.log_master_bufsize);		if (rlen <= 0) continue;		ut->pos = 0;		ut->len = (size_t) rlen;		ut->custom0 = 0;		curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t) ut->len);		CURLcode res = curl_easy_perform(curl);		if (res != CURLE_OK) {			uwsgi_log_alarm("-curl] curl_easy_perform() failed: %s/n", curl_easy_strerror(res));		}			}}

int uwsgi_ssh_url_parser(char *url, struct uwsgi_ssh_mountpoint **usm) {	// [ssh://]username[:password]@host:port/path	if (!url || !(*usm)) {		return -1;	}	if (!memcmp(url, "ssh://", 6)) {		url += 6;	}	// first of all, the remote path	char *slash = strchr(url, '/');	if (slash) {		*slash = 0;		(*usm)->path = uwsgi_concat2("/", slash + 1);	} else {		uwsgi_log("[SSH] malformed ssh url (path)/n");		return -1;	}	// then, the user:password	char *at = strchr(url, '@');	if (at) {		*at = 0;		char *colon = strchr(url, ':');		if (colon) {			*colon = 0;			(*usm)->password = uwsgi_str(colon + 1);		} else {			(*usm)->password = NULL;  // there is no password!		}		(*usm)->username = uwsgi_str(url);		// and eventually, the remote host (ip:port)		(*usm)->remote = uwsgi_str(at + 1);	} else {		(*usm)->remote = uwsgi_str(url);	}	return 0;}

void uwsgi_opt_add_daemon(char *opt, char *value, void *none) {	struct uwsgi_daemon *uwsgi_ud = uwsgi.daemons, *old_ud;	char *pidfile = NULL;	int daemonize = 0;	int freq = 10;	char *command = uwsgi_str(value);	if (!strcmp(opt, "smart-attach-daemon") || !strcmp(opt, "smart-attach-daemon2")) {		char *space = strchr(command, ' ');		if (!space) {			uwsgi_log("invalid smart-attach-daemon syntax: %s/n", command);			exit(1);		}		*space = 0;		pidfile = command;		// check for freq		char *comma = strchr(pidfile, ',');		if (comma) {			*comma = 0;			freq = atoi(comma + 1);		}		command = space + 1;		if (!strcmp(opt, "smart-attach-daemon2")) {			daemonize = 1;		}	}	if (!uwsgi_ud) {		uwsgi.daemons = uwsgi_malloc(sizeof(struct uwsgi_daemon));		uwsgi_ud = uwsgi.daemons;	}	else {		while (uwsgi_ud) {			old_ud = uwsgi_ud;			uwsgi_ud = uwsgi_ud->next;		}		uwsgi_ud = uwsgi_malloc(sizeof(struct uwsgi_daemon));		old_ud->next = uwsgi_ud;	}	uwsgi_ud->command = command;	uwsgi_ud->pid = 0;	uwsgi_ud->status = 0;	uwsgi_ud->freq = freq;	uwsgi_ud->registered = 0;	uwsgi_ud->next = NULL;	uwsgi_ud->respawns = 0;	uwsgi_ud->last_spawn = 0;	uwsgi_ud->daemonize = daemonize;	uwsgi_ud->pidfile = pidfile;	uwsgi.daemons_cnt++;}

static void uwsgi_webdav_add_a_prop(xmlNode *node, char *opt, xmlNode *req_prop, int type, char *force_name) {	char *first_space = strchr(opt, ' ');	if (!first_space) return;	*first_space = 0;	char *second_space = strchr(first_space + 1, ' ');	xmlNode *new_node = NULL;	char *ns = opt;	if (!force_name) force_name = first_space + 1;	else {		ns = "DAV:";	}	if (second_space) {		*second_space = 0;		if (!uwsgi_webdav_prop_requested(req_prop, ns, force_name)) {                	*first_space = ' ';                        *second_space = ' ';                        return;                }		// href		if (type == 1) {			new_node = xmlNewChild(node, NULL, BAD_CAST first_space + 1, NULL);			xmlNewTextChild(new_node, NULL, BAD_CAST "href", BAD_CAST second_space + 1);		}		// comp		else if (type == 2) {			new_node = xmlNewChild(node, NULL, BAD_CAST first_space + 1, NULL);			char *comps = uwsgi_str(second_space + 1);			char *p = strtok(comps, ",");			while(p) {				xmlNode *comp = xmlNewChild(new_node, NULL, BAD_CAST "comp", NULL);				xmlNewProp(comp, BAD_CAST "name", BAD_CAST p);				p = strtok(NULL, ",");			}			free(comps);		}		else {			if (!uwsgi_webdav_prop_requested(req_prop, ns, first_space + 1)) {                                *first_space = ' ';                                *second_space = ' ';                                return;                        }			new_node = xmlNewTextChild(node, NULL, BAD_CAST first_space + 1, BAD_CAST second_space + 1);		}		*second_space = ' ';	}	else {		if (!uwsgi_webdav_prop_requested(req_prop, ns, force_name)) {                        *first_space = ' ';                        return;                }		new_node = xmlNewChild(node, NULL, BAD_CAST first_space + 1, NULL);	}	xmlNsPtr x_ns = xmlNewNs(new_node, BAD_CAST opt, NULL);	xmlSetNs(new_node, x_ns);	*first_space = ' ';}

static int uwsgi_routing_func_rpc_blob(struct wsgi_request *wsgi_req, struct uwsgi_route *ur) {        int ret = -1;        // this is the list of args        char *argv[UMAX8];        // this is the size of each argument        uint16_t argvs[UMAX8];        // this is a placeholder for tmp uwsgi_buffers        struct uwsgi_buffer *ubs[UMAX8];        char **r_argv = (char **) ur->data2;        uint16_t *r_argvs = (uint16_t *) ur->data3;        char **subject = (char **) (((char *)(wsgi_req))+ur->subject);        uint16_t *subject_len = (uint16_t *)  (((char *)(wsgi_req))+ur->subject_len);        uint64_t i;        for(i=0;i<ur->custom;i++) {                ubs[i] = uwsgi_routing_translate(wsgi_req, ur, *subject, *subject_len, r_argv[i], r_argvs[i]);                if (!ubs[i]) goto end;                argv[i] = ubs[i]->buf;                argvs[i] = ubs[i]->pos;        }        // ok we now need to check it it is a local call or a remote one        char *func = uwsgi_str(ur->data);        char *remote = NULL;        char *at = strchr(func, '@');        if (at) {                *at = 0;                remote = at+1;        }        uint16_t size;        char *response = uwsgi_do_rpc(remote, func, ur->custom, argv, argvs, &size);        free(func);        if (!response) goto end;        ret = UWSGI_ROUTE_NEXT;	// optimization	if (!wsgi_req->headers_sent) {        	if (uwsgi_response_prepare_headers(wsgi_req, "200 OK", 6)) {free(response) ; goto end;}        	if (uwsgi_response_add_connection_close(wsgi_req)) {free(response) ; goto end;}	}        uwsgi_response_write_body_do(wsgi_req, response, size);        free(response);end:        for(i=0;i<ur->custom;i++) {                if (ubs[i] != NULL) {                        uwsgi_buffer_destroy(ubs[i]);                }        }        return ret;}

int fastrouter_opt(int i, char *optarg) {	char *cs;	char *cs_code;	char *cs_func;	switch(i) {		case LONG_ARGS_FASTROUTER:			uwsgi_fastrouter_new_socket(generate_socket_name(optarg));			return 1;		case LONG_ARGS_FASTROUTER_SUBSCRIPTION_SERVER:			ufr.subscription_server = optarg;			return 1;		case LONG_ARGS_FASTROUTER_EVENTS:			ufr.nevents = atoi(optarg);			return 1;		case LONG_ARGS_FASTROUTER_USE_PATTERN:			ufr.pattern = optarg;			// optimization			ufr.pattern_len = strlen(ufr.pattern);			return 1;		case LONG_ARGS_FASTROUTER_USE_BASE:			ufr.base = optarg;			// optimization			ufr.base_len = strlen(ufr.base);			return 1;		case LONG_ARGS_FASTROUTER_USE_CODE_STRING:			cs = uwsgi_str(optarg);			cs_code = strchr(cs, ':');			if (!cs_code) {				uwsgi_log("invalid code_string option/n");				exit(1);				}			cs_code[0] = 0;			cs_func = strchr(cs_code+1, ':');			if (!cs_func) {				uwsgi_log("invalid code_string option/n");				exit(1);				}			cs_func[0] = 0;			ufr.code_string_modifier1 = atoi(cs);			ufr.code_string_code = cs_code+1;			ufr.code_string_function = cs_func+1;			return 1;		case LONG_ARGS_FASTROUTER_TIMEOUT:			ufr.socket_timeout = atoi(optarg);			return -1;		case LONG_ARGS_FASTROUTER_SUBSCRIPTION_SLOT:			ufr.subscription_slot = atoi(optarg);			return 1;	}	return 0;}

static void uwsgi_alarm_curl_to(CURL *curl, CURLoption option, char *arg, struct uwsgi_alarm_curl_config *uacc) {	uacc->to = arg;	struct curl_slist *list = NULL;	char *items = uwsgi_str(arg);	char *ctx = NULL;	char *p = strtok_r(items, ",", &ctx);	while(p) {		list = curl_slist_append(list, p);		p = strtok_r(NULL, ",", &ctx);	}	curl_easy_setopt(curl, option, list);}

void uwsgi_emperor_simple_do(struct uwsgi_emperor_scanner *ues, char *name, char *config, time_t ts, uid_t uid, gid_t gid, char *socket_name) {	if (!uwsgi_emperor_is_valid(name))		return;	struct uwsgi_instance *ui_current = emperor_get(name);	if (ui_current) {		// check if uid or gid are changed, in such case, stop the instance		if (uwsgi.emperor_tyrant) {			if (uid != ui_current->uid || gid != ui_current->gid) {				uwsgi_log("[emperor-tyrant] !!! permissions of vassal %s changed. stopping the instance... !!!/n", name);				emperor_stop(ui_current);				return;			}		}		// check if mtime is changed and the uWSGI instance must be reloaded		if (ts > ui_current->last_mod) {			// make a new config (free the old one) if needed			if (config) {				if (ui_current->config)					free(ui_current->config);				ui_current->config = uwsgi_str(config);				ui_current->config_len = strlen(ui_current->config);			}			// reload the instance			emperor_respawn(ui_current, ts);		}	}	else {		// make a copy of the config as it will be freed		char *new_config = NULL;		size_t new_config_len = 0;		if (config) {			new_config = uwsgi_str(config);			new_config_len = strlen(new_config);		}		emperor_add(ues, name, ts, new_config, new_config_len, uid, gid, socket_name);	}}

static int uwsgi_sni_cb(SSL *ssl, int *ad, void *arg) {        const char *servername = SSL_get_servername(ssl, TLSEXT_NAMETYPE_host_name);        if (!servername) return SSL_TLSEXT_ERR_NOACK;        size_t servername_len = strlen(servername);        struct uwsgi_string_list *usl = uwsgi.sni;        while(usl) {                if (!uwsgi_strncmp(usl->value, usl->len, (char *)servername, servername_len)) {                        SSL_set_SSL_CTX(ssl, usl->custom_ptr);                        return SSL_TLSEXT_ERR_OK;                }                usl = usl->next;        }#ifdef UWSGI_PCRE        struct uwsgi_regexp_list *url = uwsgi.sni_regexp;        while(url) {                if (uwsgi_regexp_match(url->pattern, url->pattern_extra, (char *)servername, servername_len) >= 0) {                        SSL_set_SSL_CTX(ssl, url->custom_ptr);                        return SSL_TLSEXT_ERR_OK;                }                url = url->next;        }#endif	if (uwsgi.sni_dir) {		size_t sni_dir_len = strlen(uwsgi.sni_dir);		char *sni_dir_cert = uwsgi_concat4n(uwsgi.sni_dir, sni_dir_len, "/", 1, (char *) servername, servername_len, ".crt", 4);		char *sni_dir_key = uwsgi_concat4n(uwsgi.sni_dir, sni_dir_len, "/", 1, (char *) servername, servername_len, ".key", 4);		char *sni_dir_client_ca = uwsgi_concat4n(uwsgi.sni_dir, sni_dir_len, "/", 1, (char *) servername, servername_len, ".ca", 3);		if (uwsgi_file_exists(sni_dir_cert) && uwsgi_file_exists(sni_dir_key)) {			char *client_ca = NULL;			if (uwsgi_file_exists(sni_dir_client_ca)) {				client_ca = sni_dir_client_ca;			}			usl = uwsgi_ssl_add_sni_item(uwsgi_str((char *)servername), sni_dir_cert, sni_dir_key, uwsgi.sni_dir_ciphers, client_ca);			if (!usl) goto done;			free(sni_dir_cert);			free(sni_dir_key);			free(sni_dir_client_ca);			SSL_set_SSL_CTX(ssl, usl->custom_ptr);			uwsgi_log("[uwsgi-sni for pid %d] added context for %s/n", (int) getpid(), servername);			return SSL_TLSEXT_ERR_OK;		}done:		free(sni_dir_cert);		free(sni_dir_key);		free(sni_dir_client_ca);	}        return SSL_TLSEXT_ERR_NOACK;}

void uwsgi_opt_sni(char *opt, char *value, void *foobar) {        char *client_ca = NULL;        char *v = uwsgi_str(value);        char *space = strchr(v, ' ');        if (!space) {                uwsgi_log("invalid %s syntax, must be sni_key<space>crt,key[,ciphers,client_ca]/n", opt);                exit(1);        }        *space = 0;        char *crt = space+1;        char *key = strchr(crt, ',');        if (!key) {                uwsgi_log("invalid %s syntax, must be sni_key<space>crt,key[,ciphers,client_ca]/n", opt);                exit(1);        }        *key = '/0'; key++;        char *ciphers = strchr(key, ',');        if (ciphers) {                *ciphers = '/0'; ciphers++;                client_ca = strchr(ciphers, ',');                if (client_ca) {                        *client_ca = '/0'; client_ca++;                }        }        if (!uwsgi.ssl_initialized) {                uwsgi_ssl_init();        }        SSL_CTX *ctx = uwsgi_ssl_new_server_context(v, crt, key, ciphers, client_ca);        if (!ctx) {                uwsgi_log("[uwsgi-ssl] DANGER unable to initialize context for /"%s/"/n", v);                free(v);                return;        }#ifdef UWSGI_PCRE        if (!strcmp(opt, "sni-regexp")) {                struct uwsgi_regexp_list *url = uwsgi_regexp_new_list(&uwsgi.sni_regexp, v);                url->custom_ptr = ctx;        }        else {#endif                struct uwsgi_string_list *usl = uwsgi_string_new_list(&uwsgi.sni, v);                usl->custom_ptr = ctx;#ifdef UWSGI_PCRE        }#endif}

static void uwsgi_glusterfs_connect_do(struct uwsgi_app *ua) {	char *servers = uwsgi_str(ua->callable);	char *p = strtok(servers, ";");	while(p) {		uwsgi_log("[glusterfs] try connect to %s for mountpoint %.*s on worker %d .../n", p, ua->mountpoint_len, ua->mountpoint, uwsgi.mywid);		if (uwsgi_glusterfs_try(ua, p)) {			goto end;		}		p = strtok(NULL, ";");	}end:	free(servers);}

char *uwsgi_python_get_thread_name(PyObject *thread_id) {	PyObject *threading_module = PyImport_ImportModule("threading");	if (!threading_module) return NULL;		PyObject *threading_dict = PyModule_GetDict(threading_module);	if (!threading_dict) return NULL;	PyObject *threading_enumerate = PyDict_GetItemString(threading_dict, "enumerate");	if (!threading_enumerate) return NULL;	PyObject *threads_list = PyEval_CallObject(threading_enumerate, (PyObject *)NULL);	if (!threads_list) return NULL;	PyObject *threads_list_iter = PyObject_GetIter(threads_list);	if (!threads_list_iter) goto clear;	PyObject *threads_list_next = PyIter_Next(threads_list_iter);	while(threads_list_next) {		PyObject *thread_ident = PyObject_GetAttrString(threads_list_next, "ident");		if (!thread_ident) goto clear2;		if (PyInt_AsLong(thread_ident) == PyInt_AsLong(thread_id)) {			PyObject *thread_name = PyObject_GetAttrString(threads_list_next, "name");			if (!thread_name) goto clear2;#ifdef PYTHREE			PyObject *thread_name_utf8 = PyUnicode_AsUTF8String(thread_name);			if (!thread_name_utf8) goto clear2;			char *name = NULL;			char *tmp_name = PyString_AsString(thread_name_utf8);			if (tmp_name) {				name = uwsgi_str(tmp_name);					Py_DECREF(thread_name_utf8);			}#else			char *name = PyString_AsString(thread_name);#endif			Py_DECREF(threads_list_next);			Py_DECREF(threads_list_iter);			Py_DECREF(threads_list);			return name;		}		Py_DECREF(threads_list_next);		threads_list_next = PyIter_Next(threads_list_iter);	}clear2:	Py_DECREF(threads_list_iter);clear:	Py_DECREF(threads_list);	return NULL;}

static int uwsgi_alarm_log_add(char *alarms, char *regexp, int negate) {	struct uwsgi_alarm_log *old_ual = NULL, *ual = uwsgi.alarm_logs;	while (ual) {		old_ual = ual;		ual = ual->next;	}	ual = uwsgi_calloc(sizeof(struct uwsgi_alarm_log));	if (uwsgi_regexp_build(regexp, &ual->pattern, &ual->pattern_extra)) {		return -1;	}	ual->negate = negate;	if (old_ual) {		old_ual->next = ual;	}	else {		uwsgi.alarm_logs = ual;	}	// map instances to the log	char *list = uwsgi_str(alarms);	char *p = strtok(list, ",");	while (p) {		struct uwsgi_alarm_instance *uai = uwsgi_alarm_get_instance(p);		if (!uai) {			free(list);			return -1;		}		struct uwsgi_alarm_ll *old_uall = NULL, *uall = ual->alarms;		while (uall) {			old_uall = uall;			uall = uall->next;		}		uall = uwsgi_calloc(sizeof(struct uwsgi_alarm_ll));		uall->alarm = uai;		if (old_uall) {			old_uall->next = uall;		}		else {			ual->alarms = uall;		}		p = strtok(NULL, ",");	}	free(list);	return 0;}

void uwsgi_opt_https(char *opt, char *value, void *cr) {        struct uwsgi_corerouter *ucr = (struct uwsgi_corerouter *) cr;        char *client_ca = NULL;        // build socket, certificate and key file        char *sock = uwsgi_str(value);        char *crt = strchr(sock, ',');        if (!crt) {                uwsgi_log("invalid https syntax must be socket,crt,key/n");                exit(1);        }        *crt = '/0'; crt++;        char *key = strchr(crt, ',');        if (!key) {                uwsgi_log("invalid https syntax must be socket,crt,key/n");                exit(1);        }        *key = '/0'; key++;        char *ciphers = strchr(key, ',');        if (ciphers) {                *ciphers = '/0'; ciphers++;                client_ca = strchr(ciphers, ',');                if (client_ca) {                        *client_ca = '/0'; client_ca++;                }        }        struct uwsgi_gateway_socket *ugs = uwsgi_new_gateway_socket(sock, ucr->name);        // ok we have the socket, initialize ssl if required        if (!uwsgi.ssl_initialized) {                uwsgi_ssl_init();        }        // initialize ssl context	char *name = uhttp.https_session_context;	if (!name) {		name = uwsgi_concat3(ucr->short_name, "-", ugs->name);	}        ugs->ctx = uwsgi_ssl_new_server_context(name, crt, key, ciphers, client_ca);	if (!ugs->ctx) {		exit(1);	}        // set the ssl mode        ugs->mode = UWSGI_HTTP_SSL;        ucr->has_sockets++;}

void carbon_post_init() {	int i;	struct uwsgi_string_list *usl = u_carbon.servers;	if (!uwsgi.sockets) return;	if (!u_carbon.servers) return;	while(usl) {		struct carbon_server_list *u_server = uwsgi_calloc(sizeof(struct carbon_server_list));		u_server->value = usl->value;		u_server->healthy = 1;		u_server->errors = 0;		if (u_carbon.servers_data) {			u_server->next = u_carbon.servers_data;		}		u_carbon.servers_data = u_server;		uwsgi_log("[carbon] added server %s/n", usl->value);		usl = usl->next;	}	if (u_carbon.freq < 1) u_carbon.freq = 60;	if (u_carbon.timeout < 1) u_carbon.timeout = 3;	if (u_carbon.max_retries <= 0) u_carbon.max_retries = 1;	if (u_carbon.retry_delay <= 0) u_carbon.retry_delay = 7;	if (!u_carbon.id) { 		u_carbon.id = uwsgi_str(uwsgi.sockets->name);		for(i=0;i<(int)strlen(u_carbon.id);i++) {			if (u_carbon.id[i] == '.') u_carbon.id[i] = '_';		}	}	if (!u_carbon.last_busyness_values) {		u_carbon.last_busyness_values = uwsgi_calloc(sizeof(unsigned long long) * uwsgi.numproc);	}	if (!u_carbon.current_busyness_values) {		u_carbon.current_busyness_values = uwsgi_calloc(sizeof(unsigned long long) * uwsgi.numproc);	}	// set next update to now()+retry_delay, this way we will have first flush just after start	u_carbon.last_update = uwsgi_now() - u_carbon.freq + u_carbon.retry_delay;	uwsgi_log("[carbon] carbon plugin started, %is frequency, %is timeout, max retries %i, retry delay %is/n",		u_carbon.freq, u_carbon.timeout, u_carbon.max_retries, u_carbon.retry_delay);}

static void router_xmldir_register(void) {	char *codeset;	uwsgi_register_router("xmldir", uwsgi_router_xmldir);	setlocale(LC_ALL, "");	if ((codeset = nl_langinfo(CODESET)) == '/0') {		codeset = "ASCII";	}	conf.codeset = uwsgi_str(codeset);	if (conf.codeset == NULL) {		uwsgi_error("strdup()");		exit(1);	}}

ssize_t uwsgi_syslog_logger(struct uwsgi_logger *ul, char *message, size_t len) {	char *syslog_opts;	int facility = LOG_DAEMON;	if (!ul->configured) {        	setlinebuf(stderr);        	if (ul->arg == NULL) {                	syslog_opts = "uwsgi";        	}		else {			char *colon = strchr(ul->arg, ',');			if (colon) {				struct uwsgi_syslog_facility *fn = usf;				while(fn->name) {					if (!strcmp(fn->name, colon+1)) {						facility = fn->facility;						break;					}					fn++;				}				syslog_opts = uwsgi_str(ul->arg);				syslog_opts[colon-ul->arg] = 0;			}			else {				syslog_opts = ul->arg;			}		}        	openlog(syslog_opts, 0, facility);		ul->configured = 1;	}#ifdef __APPLE__	syslog(LOG_NOTICE, "%.*s", (int) len, message);#else	syslog(LOG_INFO, "%.*s", (int) len, message);#endif	return 0;}

void uwsgi_opt_http_to_https(char *opt, char *value, void *cr) {        struct uwsgi_corerouter *ucr = (struct uwsgi_corerouter *) cr;        char *sock = uwsgi_str(value);        char *port = strchr(sock, ',');        if (port) {                *port = '/0';                port++;        }        struct uwsgi_gateway_socket *ugs = uwsgi_new_gateway_socket(sock, ucr->name);        // set context to the port        ugs->ctx = port;        // force SSL mode        ugs->mode = UWSGI_HTTP_FORCE_SSL;        ucr->has_sockets++;}

void uwsgi_opt_add_route(char *opt, char *value, void *foobar) {	struct uwsgi_route *old_ur = NULL,*ur = uwsgi.routes;	uint64_t pos = 0;	while(ur) {		old_ur = ur;		ur = ur->next;		pos++;	}	ur = uwsgi_calloc(sizeof(struct uwsgi_route));	if (old_ur) {		old_ur->next = ur;	}	else {		uwsgi.routes = ur;	}	ur->pos = pos;	// is it a label ?	if (foobar == NULL) {		ur->label = value;		ur->label_len = strlen(value);		return;	}	char *route = uwsgi_str(value);	char *space = strchr(route, ' ');	if (!space) {		uwsgi_log("invalid route syntax/n");		exit(1);	}	*space = 0;	if (!strcmp(foobar, "http_host")) {		ur->subject = offsetof(struct wsgi_request, host);		ur->subject_len = offsetof(struct wsgi_request, host_len);	}

void carbon_post_init() {	int i;	struct uwsgi_string_list *usl = u_carbon.servers;	if (!uwsgi.sockets) return;	if (!u_carbon.servers) return;	while(usl) {		uwsgi_log("added carbon server %s/n", usl->value);		usl = usl->next;	}	if (u_carbon.freq < 1) u_carbon.freq = 60;	if (u_carbon.timeout < 1) u_carbon.timeout = 3;	if (!u_carbon.id) { 		u_carbon.id = uwsgi_str(uwsgi.sockets->name);		for(i=0;i<(int)strlen(u_carbon.id);i++) {			if (u_carbon.id[i] == '.') u_carbon.id[i] = '_';		}	}}

void uwsgi_stats_pusher_setup() {	struct uwsgi_string_list *usl = uwsgi.requested_stats_pushers;	while (usl) {		char *ssp = uwsgi_str(usl->value);		struct uwsgi_stats_pusher *pusher = NULL;		char *colon = strchr(ssp, ':');		if (colon) {			*colon = 0;		}		pusher = uwsgi_stats_pusher_get(ssp);		if (!pusher) {			uwsgi_log("unable to find /"%s/" stats_pusher/n", ssp);			exit(1);		}		char *arg = NULL;		if (colon) {			arg = colon + 1;			*colon = ':';		}		uwsgi_stats_pusher_add(pusher, arg);		usl = usl->next;	}}

char *uwsgi_getsockname(int fd) {	socklen_t socket_type_len = sizeof(struct sockaddr_un);	union uwsgi_sockaddr usa;	union uwsgi_sockaddr_ptr gsa;	char computed_port[6];	char ipv4a[INET_ADDRSTRLEN + 1];	gsa.sa = (struct sockaddr *) &usa;	if (!getsockname(fd, gsa.sa, &socket_type_len)) {		if (gsa.sa->sa_family == AF_UNIX) {			if (usa.sa_un.sun_path[0] == 0) {				return uwsgi_concat2("@", usa.sa_un.sun_path + 1);			}			else {				return uwsgi_str(usa.sa_un.sun_path);			}		}		else {			memset(ipv4a, 0, INET_ADDRSTRLEN + 1);			memset(computed_port, 0, 6);			if (snprintf(computed_port, 6, "%d", ntohs(gsa.sa_in->sin_port)) > 0) {				if (inet_ntop(AF_INET, (const void *) &gsa.sa_in->sin_addr.s_addr, ipv4a, INET_ADDRSTRLEN)) {					if (!strcmp("0.0.0.0", ipv4a)) {						return uwsgi_concat2(":", computed_port);					}					else {						return uwsgi_concat3(ipv4a, ":", computed_port);					}				}			}		}	}	return NULL;}

static int uwsgi_jwsgi_add_request_item(jobject hm, char *key, uint16_t key_len, char *value, uint16_t value_len) {	jobject j_key = uwsgi_jvm_str(key, key_len);	if (!j_key) return -1;	jobject j_value = NULL;	// avoid clobbering vars	if (value_len > 0) {		j_value = uwsgi_jvm_str(value, value_len);	}	else {		char *tmp = uwsgi_str("");		j_value = uwsgi_jvm_str(tmp, 0);		free(tmp);	}	if (!j_value) {		uwsgi_jvm_local_unref(j_value);		return -1;	}	int ret = uwsgi_jvm_hashmap_put(hm, j_key, j_value);	uwsgi_jvm_local_unref(j_key);	uwsgi_jvm_local_unref(j_value);	return ret;}

void uwsgi_opt_corerouter_cs(char *opt, char *value, void *cr) {	struct uwsgi_corerouter *ucr = (struct uwsgi_corerouter *) cr;        char *cs = uwsgi_str(value);               char *cs_code = strchr(cs, ':');                if (!cs_code) {                        uwsgi_log("invalid code_string option/n");                        exit(1);                }                cs_code[0] = 0;                char *cs_func = strchr(cs_code + 1, ':');                if (!cs_func) {                        uwsgi_log("invalid code_string option/n");                        exit(1);                }                cs_func[0] = 0;                ucr->code_string_modifier1 = atoi(cs);                ucr->code_string_code = cs_code + 1;                ucr->code_string_function = cs_func + 1;	ucr->has_backends++;}