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

static int dsi_event_thread(void *data){	struct mdss_dsi_event *ev;	struct dsi_event_q *evq;	struct mdss_dsi_ctrl_pdata *ctrl;	unsigned long flag;	struct sched_param param;	u32 todo = 0;	int ret;	param.sched_priority = 16;	ret = sched_setscheduler_nocheck(current, SCHED_FIFO, &param);	if (ret)		pr_err("%s: set priority failed/n", __func__);	ev = (struct mdss_dsi_event *)data;	/* event */	init_waitqueue_head(&ev->event_q);	spin_lock_init(&ev->event_lock);	while (1) {		wait_event(ev->event_q, (ev->event_pndx != ev->event_gndx));		spin_lock_irqsave(&ev->event_lock, flag);		evq = &ev->todo_list[ev->event_gndx++];		todo = evq->todo;		ctrl = evq->ctrl;		evq->todo = 0;		ev->event_gndx %= DSI_EVENT_Q_MAX;		spin_unlock_irqrestore(&ev->event_lock, flag);		pr_debug("%s: ev=%x/n", __func__, todo);#if defined (CONFIG_FB_MSM_MDSS_DSI_DBG)		xlog(__func__, todo, 0, 0, 0, 0, 0);#endif		if (todo & DSI_EV_PLL_UNLOCKED)			mdss_dsi_pll_relock(ctrl);		if (todo & DSI_EV_MDP_FIFO_UNDERFLOW) {			if (ctrl->recovery) {				mdss_dsi_sw_reset_restore(ctrl);				ctrl->recovery->fxn(ctrl->recovery->data);			}		}		if (todo & DSI_EV_MDP_BUSY_RELEASE) {			spin_lock_irqsave(&ctrl->mdp_lock, flag);			ctrl->mdp_busy = false;			mdss_dsi_disable_irq_nosync(ctrl, DSI_MDP_TERM);			complete(&ctrl->mdp_comp);			spin_unlock_irqrestore(&ctrl->mdp_lock, flag);			/* enable dsi error interrupt */			mdss_dsi_err_intr_ctrl(ctrl, DSI_INTR_ERROR_MASK, 1);		}	}	return 0;}

/* * E8. [Go down a floor.] This step is like E7 with directions reversed, and also *     the times 51 and 14 are changed to 61 and 23, respectively. (It takes the *     elevator longer to go down than up.) */void E8A(void){	int j;	int all_zero = 1;	for (j = MIN_FLOOR; j < FLOOR; j++) {		if (CALLUP[j] || CALLDOWN[j] || CALLCAR[j]) {			/** the car need not go downstairs anymore			 *  because nobody's there and nobody's getting there			 */			all_zero = 0;			break;		}	}	xlog(LOG_E,	     "E8A(). "	     "FLOOR:%d. CALLCAR[%d]:%d. "	     "CALLUP[%d]:%d. CALLDOWN[%d]:%d. "	     "CALLUP[0..4]:%d,%d,%d,%d,%d. "	     "CALLDOWN[0..4]:%d,%d,%d,%d,%d."	     "CALLCAR[0..4]:%d,%d,%d,%d,%d./n",	     FLOOR, FLOOR, CALLCAR[FLOOR],	     FLOOR, CALLUP[FLOOR], FLOOR, CALLDOWN[FLOOR],	     CALLUP[0], CALLUP[1], CALLUP[2], CALLUP[3], CALLUP[4],	     CALLDOWN[0], CALLDOWN[1], CALLDOWN[2], CALLDOWN[3], CALLDOWN[4],	     CALLCAR[0], CALLCAR[1], CALLCAR[2], CALLCAR[3], CALLCAR[4]);	if (CALLCAR[FLOOR] || CALLDOWN[FLOOR] ||	    ((FLOOR == 2 || CALLUP[FLOOR]) && all_zero)) {		in_WAIT(TIME + 23, E2, NO_ARG); /** change state */		return;	}	else {		E8();		/** repeat E8 */	}}

/** ptr: &uinfo[] */void U1(struct user_info * p){	xlog(LOG_U, "U1(). %s arrives at floor %d, destination is %d./n",	     p->name, p->IN, p->OUT);	U2(p);}

/* * E7. [Go up a floor.] Set FLOOR <-- FLOOR + 1 and wait 51 units of time. If *     now CALLCAR[FLOOR] == 1 or CALLUP[FLOOR] == 1, or *     if ((FLOOR == 2 or CALLDOWN[FLOOR] == 1) and *         CALLUP[j] == CALLDOWN[j] == CALLCAR[j] == 0 for all j > FLOOR), *     wait 14 units (for deceleration) and go to E2. Otherwise, *     repeat this step. */void E7A(void){	int j;	int all_zero = 1;	for (j = MAX_FLOOR; j > FLOOR; j--) {		if (CALLUP[j] || CALLDOWN[j] || CALLCAR[j]) {			all_zero = 0;			break;		}	}	if (CALLCAR[FLOOR] || CALLUP[FLOOR] ||	    ((FLOOR == 2 || CALLDOWN[FLOOR]) && all_zero)) {		xlog(LOG_E,		     "E7A(). "		     "FLOOR:%d. CALLCAR[%d]:%d. "		     "CALLUP[%d]:%d. CALLDOWN[%d]:%d. "		     "CALLUP[0..4]:%d,%d,%d,%d,%d. "		     "CALLDOWN[0..4]:%d,%d,%d,%d,%d."		     "CALLCAR[0..4]:%d,%d,%d,%d,%d./n",		     FLOOR, FLOOR, CALLCAR[FLOOR],		     FLOOR, CALLUP[FLOOR], FLOOR, CALLDOWN[FLOOR],		     CALLUP[0], CALLUP[1], CALLUP[2], CALLUP[3], CALLUP[4],		     CALLDOWN[0], CALLDOWN[1], CALLDOWN[2], CALLDOWN[3], CALLDOWN[4],		     CALLCAR[0], CALLCAR[1], CALLCAR[2], CALLCAR[3], CALLCAR[4]);		in_WAIT(TIME + 14, E2, NO_ARG); /** change state */		return;	}	else {		E7();		/** repeat E7 */	}}

/* * E3. [Open doors.] Set D1 and D2 to any nonzero values. Set elevator activity *     E9 to start up independently after 300 units of time. (This activity may be *     canceled in step E6 below before it occurs. If it has already been scheduled *     and not canceled, we cancel it and reschedule it.) Also set elevator activity *     E5 to start up independently after 76 units of time. Then wait 20 units of *     time (to simulate opening of the doors) and go to E4. */void E3(void){	xlog(LOG_E, "E3(). Open doors./n");	D1 = 1;	D2 = 1;	if (dormant) {		dormant = 0;		xlog(LOG_E, "E3(). Elevator no more dormant./n");	}	in_WAIT(TIME + 20, E4, NO_ARG); /** let people out, in */	in_WAIT(TIME + 76, E5, NO_ARG); /** close doors */	out_WAIT(E9, 0);		/** cancel E9 if it has been scheduled */	in_WAIT(TIME + 300, E9, NO_ARG); /** set inaction indicator */}

int mHalJpgDecParser(unsigned char* srcAddr, unsigned int srcSize){    pthread_mutex_lock(&resMutex);        if(jpgDecoder != NULL)     {        xlog("hw decoder is busy");        pthread_mutex_unlock(&resMutex);        //return JPEG_ERROR_INVALID_DRIVER;        return MHAL_INVALID_RESOURCE;    }    jpgDecoder = new JpgDecHal();        pthread_mutex_unlock(&resMutex);    if(!jpgDecoder->lock())    {        return return_false("can't lock resource");    }    jpgDecoder->setSrcAddr(srcAddr);    jpgDecoder->setSrcSize(srcSize);        if(!jpgDecoder->parse()) { return return_false("no support file format"); }    return 0;}

/** * from_local - determine whether request comes from the local system * @sap: pointer to socket address to check * * With virtual hosting, each hardware network interface can have * multiple network addresses. On such machines the number of machine * addresses can be surprisingly large. * * We also expect the local network configuration to change over time, * so call getifaddrs(3) more than once, but not too often. * * Returns TRUE if the sockaddr contains an address of one of the local * network interfaces.  Otherwise FALSE is returned. */intfrom_local(const struct sockaddr *sap){	static struct ifaddrs *ifaddr = NULL;	static time_t last_update = 0;	struct ifaddrs *ifa;	unsigned int count;	time_t now;	if (time(&now) == ((time_t)-1)) {		xlog(L_ERROR, "%s: time(2): %m", __func__);		/* If we don't know what time it is, use the		 * existing ifaddr list, if one exists  */		now = last_update;		if (ifaddr == NULL)			now++;	}	if (now != last_update) {		xlog(D_GENERAL, "%s: updating local if addr list", __func__);		if (ifaddr)			freeifaddrs(ifaddr);		if (getifaddrs(&ifaddr) == -1) {			xlog(L_ERROR, "%s: getifaddrs(3): %m", __func__);			return FALSE;		}		last_update = now;	}	count = 0;	for (ifa = ifaddr; ifa; ifa = ifa->ifa_next) {		if ((ifa->ifa_flags & IFF_UP) &&		    nfs_compare_sockaddr(sap, ifa->ifa_addr)) {			xlog(D_GENERAL, "%s: incoming address matches "					"local interface address", __func__);			return TRUE;		} else			count++;	}	xlog(D_GENERAL, "%s: checked %u local if addrs; "			"incoming address not found", __func__, count);	return FALSE;}

int proxenet_ruby_initialize_function(plugin_t* plugin, req_t type){	/* checks */	if (!plugin->name) {		xlog(LOG_ERROR, "%s/n", "null plugin name");		return -1;	}	if (proxenet_ruby_load_file(plugin) < 0) {		xlog(LOG_ERROR, "Failed to load %s/n", plugin->filename);		return -1;	}	/* get function ID */	switch(type) {		case REQUEST:			if (plugin->pre_function) {				xlog(LOG_WARNING, "Pre-hook function already defined for '%s'/n", plugin->name);				return 0;			}			plugin->pre_function  = (void*) rb_intern(CFG_REQUEST_PLUGIN_FUNCTION);			if (plugin->pre_function) {#ifdef DEBUG				xlog(LOG_DEBUG, "Loaded %s:%s/n", plugin->filename, CFG_REQUEST_PLUGIN_FUNCTION);#endif				return 0;			}			break;		case RESPONSE:			if (plugin->post_function) {				xlog(LOG_WARNING, "Post-hook function already defined for '%s'/n", plugin->name);				return 0;			}			plugin->post_function = (void*) rb_intern(CFG_RESPONSE_PLUGIN_FUNCTION);			if (plugin->post_function) {#ifdef DEBUG				xlog(LOG_DEBUG, "Loaded %s:%s/n", plugin->filename, CFG_RESPONSE_PLUGIN_FUNCTION);#endif				return 0;			}			break;		default:			xlog(LOG_CRITICAL, "%s/n", "Should never be here, autokill !");			abort();			break;	}	xlog(LOG_ERROR, "%s/n", "Failed to find function");	return -1;}

void show_prof(void){	int n,m;	double proz;	int tab[100];#ifdef BIGPROF	unsigned long long total=0;#endif	for (n=0; n<100; n++) {		tab[n]=n;	}	qsort(tab,100,sizeof(int),profsort);	xlog("----- Profile: -----");	for (n=1; n<100; n++) {		m=tab[n];		if (!proftab[m].cycles) break;		proz=100.0/proftab[0].cycles*proftab[m].cycles;		if (proz<0.1) break;                xlog("%-13.13s %5.2f%%",profname[m],proz);	}	xlog("--------------------");		showmem();#ifdef BIGPROF		qsort(prof,maxprof,sizeof(struct profile),profcomp);		for (n=0; n<maxprof; n++) if (!prof[n].task[1]) total+=prof[n].cycles;		for (n=0; n<maxprof; n++) {		for (m=0; m<10 && prof[n].task[m]; m++) {			printf("%s ",profname[prof[n].task[m]]);		}		printf("%llu calls, %llu cycles, %.2f%%/n",prof[n].calls,prof[n].cycles,100.0/total*prof[n].cycles);	}	bzero(prof,sizeof(prof));	maxprof=0;#endif	//xcheck();	xlog("serials: char=%d, item=%d",sercn,serin);}

void mdss_dsi_clk_req(struct mdss_dsi_ctrl_pdata *ctrl, int enable){#if defined (CONFIG_FB_MSM_MDSS_DSI_DBG)	xlog(__func__,ctrl->ndx, enable, ctrl->mdp_busy, 0x111, 0, current->pid);#endif	if (enable == 0) {		/* need wait before disable */		mutex_lock(&ctrl->cmd_mutex);		mdss_dsi_cmd_mdp_busy(ctrl);		mutex_unlock(&ctrl->cmd_mutex);	}#if defined (CONFIG_FB_MSM_MDSS_DSI_DBG)	xlog(__func__,ctrl->ndx, enable, ctrl->mdp_busy, 0x222, 0, current->pid);#endif	mdss_dsi_clk_ctrl(ctrl, enable);}

/** * DNS solve a host name to its IP address. If `type` argument is -1, IP address * return can be of any type (AF_INET or AF_INET6). If type is specified and solved * type do not match, return an error. * * @param host name to solve * @param IP address type to enforce, -1 for any type * @return a pointer to the IP address, or NULL if an error occured */char* proxenet_resolve_hostname(char* hostname, int type){        struct hostent *hostent;        hostent = gethostbyname(hostname);        if(!hostent){                xlog(LOG_ERROR, "Failed to solve '%s': %s/n", hostname, strerror(h_errno));                return NULL;        }        if( (type != -1) && (type != hostent->h_addrtype) ){                xlog(LOG_ERROR, "IP address type wanted (%d) does not match the received (%d)/n", type, hostent->h_addrtype);                return NULL;        }        return hostent->h_addr_list[0];}

void generic_http_error_page(sock_t sock, char* msg){	char* html_header = "<html><body><h1>proxenet error page</h1><br/>";	char* html_footer = "</body></html>";		if (write(sock, html_header, strlen(html_header)) < 0) {		xlog(LOG_ERROR, "%s/n", "Failed to write error HTML header");	}		if(write(sock, msg, strlen(msg)) < 0){		xlog(LOG_ERROR, "%s/n", "Failed to write error HTML page");	}		if(write(sock, html_footer, strlen(html_footer)) < 0){		xlog(LOG_ERROR, "%s/n", "Failed to write error HTML footer");	}}

/* * If a port is specified on the command line, that port value will be * the same for all listeners created here.  Create each listener * socket in advance and set SO_REUSEADDR, rather than allowing the * RPC library to create the listeners for us on a randomly chosen * port via svc_tli_create(RPC_ANYFD). * * Some callers want to listen for more than one RPC version using the * same port number.  For example, mountd could want to listen for MNT * version 1, 2, and 3 requests.  This means mountd must use the same * set of listener sockets for multiple RPC versions, since, on one * system, you can't have two listener sockets with the exact same * bind address (and port) and transport protocol. * * To accomplish this, this function caches xprts as they are created. * This cache is checked to see if a previously created xprt can be * used, before creating a new xprt for this [program, version].  If * there is a cached xprt with the same bindaddr and transport * semantics, we simply register the new version with that xprt, * rather than creating a fresh xprt for it. * * The xprt cache implemented here is local to a process.  Two * separate RPC daemons can not share a set of listeners. * * Returns the count of started listeners (one or zero). */static unsigned intsvc_create_nconf_fixed_port(const char *name, const rpcprog_t program,                            const rpcvers_t version,                            void (*dispatch)(struct svc_req *, SVCXPRT *),                            const uint16_t port, struct netconfig *nconf){    struct addrinfo *ai;    SVCXPRT	*xprt;    ai = svc_create_bindaddr(nconf, port);    if (ai == NULL)        return 0;    xprt = svc_create_find_xprt(ai->ai_addr, nconf);    if (xprt == NULL) {        int fd;        fd = svc_create_sock(ai->ai_addr, ai->ai_addrlen, nconf);        if (fd == -1)            goto out_free;        xprt = svc_tli_create(fd, nconf, NULL, 0, 0);        if (xprt == NULL) {            xlog(D_GENERAL, "Failed to create listener xprt "                 "(%s, %u, %s)", name, version, nconf->nc_netid);            (void)close(fd);            goto out_free;        }    }    if (!svc_reg(xprt, program, version, dispatch, nconf)) {        /* svc_reg(3) destroys @xprt in this case */        xlog(D_GENERAL, "Failed to register (%s, %u, %s)",             name, version, nconf->nc_netid);        goto out_free;    }    svc_create_cache_xprt(xprt);    freeaddrinfo(ai);    return 1;out_free:    freeaddrinfo(ai);    return 0;}

int proxenet_initialize_plugins_list(){	if(proxenet_create_list_plugins(cfg->plugins_path) < 0) {		xlog(LOG_ERROR, "%s/n", "Failed to build plugins list, leaving");		return -1;	}		if(cfg->verbose) {		xlog(LOG_INFO, "%s/n", "Plugins loaded");		if (cfg->verbose > 1) {			xlog(LOG_INFO, "%d plugin(s) found/n", proxenet_plugin_list_size());			proxenet_print_plugins_list(-1);		}	}		return 0;}

/* This list basically indicates what node(s) is/are transmitting on the * medium.   It is up to the sub class of PhysicalMedium to make the decision * as to whether there are collisions or not. */voidPhysicalMedium::addNodeToTxList(DeviceNode* node){	assert(node);	xlog(LOG_DEBUG, "%s: Add Node ID (0x%016llx) to Tx list",			pimpl->name, node->getNodeId());	pimpl->txList.push_back(node);}

/** * realloc(3) wrapper. Checks size and zero-fill buffer. * * @param oldptr: pointer to previous area * @param new_size: new size to allocate * @return a pointer to resized pointer */void* proxenet_xrealloc(void* oldptr, size_t new_size){	void *newptr;	if (new_size > (SIZE_MAX / sizeof(size_t))) {		xlog(LOG_CRITICAL, "proxenet_xrealloc: try to allocate incorrect size (%d byte)/n", new_size);		abort();	}	newptr = realloc(oldptr, new_size);	if (newptr == NULL) {		xlog(LOG_CRITICAL, "proxenet_xrealloc() failed to allocate space: %s/n", strerror(errno));		abort();	}	return newptr;}

/** * Check and change a plugin prority. * * @param p is the reference to the plugin to update * @param prority is the new prority to apply * @return 0 upon success, or -1 if a check has failed. */int proxenet_plugin_set_prority(unsigned short plugin_id, unsigned short priority){        plugin_t* plugin;        plugin_t* p;        bool has_changed;        plugin = proxenet_get_plugin_by_id( plugin_id );        if (!plugin)                return -1;        if (priority==0 || priority>=10)                return -1;        if (!plugins_list)                return -1;        if (!plugin)                return -1;        /* 1. unlink `plugin` */        has_changed = false;        for (p=plugins_list; p!=NULL; p=p->next){                if (p->next == plugin){                        p->next = plugin->next;                        has_changed = true;                        break;                }        }        if (!has_changed)                return -1;        /* 2. relink `plugin` in its new position */        has_changed = false;        for (p=plugins_list; p!=NULL; p=p->next){                if (p->priority > priority)                        continue;                plugin->next = p->next;                p->next = plugin;                plugin->priority = priority;                has_changed = true;        }        if (!has_changed)                return -1;        if (cfg->verbose){                xlog(LOG_INFO,                     "Plugin %hu '%s' has a priority of %hu/n",                     plugin->id,                     plugin->name,                     plugin->priority);        }        return 0;}

void soultrans_equipment(int cn,int in,int in2){	int stren,rank,ran;		rank=it[in].data[0];		while (rank) {		stren=RANDOM(rank+1);		rank-=stren;				if (it[in].flags&IF_WEAPON) ran=RANDOM(27);		else ran=RANDOM(26);				switch(ran) {			case 0:		it[in2].hp[2]+=stren*25; it[in2].hp[0]+=stren*5; break;			case 1:		it[in2].mana[2]+=stren*25; it[in2].mana[0]+=stren*5; break;			case 2:			case 3:			case 4:			case 5:			case 6:		over_add(it[in2].attrib[ran-2][2],stren*3); it[in2].attrib[ran-2][0]+=stren/2; break;						case 7:		over_add(it[in2].skill[SK_DAGGER][2],stren*5); it[in2].skill[SK_DAGGER][0]+=stren; break;			case 8:		over_add(it[in2].skill[SK_SWORD][2],stren*5); it[in2].skill[SK_SWORD][0]+=stren; break;			case 9:		over_add(it[in2].skill[SK_TWOHAND][2],stren*5); it[in2].skill[SK_TWOHAND][0]+=stren; break;			case 10:	over_add(it[in2].skill[SK_STEALTH][2],stren*5); it[in2].skill[SK_STEALTH][0]+=stren; break;			case 11:	over_add(it[in2].skill[SK_MSHIELD][2],stren*5); it[in2].skill[SK_MSHIELD][0]+=stren; break;			case 12:	over_add(it[in2].skill[SK_PROTECT][2],stren*5); it[in2].skill[SK_PROTECT][0]+=stren; break;			case 13:	over_add(it[in2].skill[SK_ENHANCE][2],stren*5); it[in2].skill[SK_ENHANCE][0]+=stren; break;			case 14:	over_add(it[in2].skill[SK_STUN][2],stren*5); it[in2].skill[SK_STUN][0]+=stren; break;			case 15:	over_add(it[in2].skill[SK_CURSE][2],stren*5); it[in2].skill[SK_CURSE][0]+=stren; break;			case 16:	over_add(it[in2].skill[SK_BLESS][2],stren*5); it[in2].skill[SK_BLESS][0]+=stren; break;			case 17:	over_add(it[in2].skill[SK_RESIST][2],stren*5); it[in2].skill[SK_RESIST][0]+=stren; break;			case 18:	over_add(it[in2].skill[SK_BLAST][2],stren*5); it[in2].skill[SK_BLAST][0]+=stren; break;			case 19:	over_add(it[in2].skill[SK_HEAL][2],stren*5); it[in2].skill[SK_HEAL][0]+=stren; break;			case 20:	over_add(it[in2].skill[SK_GHOST][2],stren*5); it[in2].skill[SK_GHOST][0]+=stren; break;			case 21:	over_add(it[in2].skill[SK_IMMUN][2],stren*5); it[in2].skill[SK_IMMUN][0]+=stren; break;			case 22:	over_add(it[in2].skill[SK_SURROUND][2],stren*5); it[in2].skill[SK_SURROUND][0]+=stren; break;			case 23:	over_add(it[in2].skill[SK_CONCEN][2],stren*5); it[in2].skill[SK_CONCEN][0]+=stren; break;			case 24:	over_add(it[in2].skill[SK_WARCRY][2],stren*5); it[in2].skill[SK_WARCRY][0]+=stren; break;			case 25:	it[in2].armor[0]+=stren/2; break;			case 26:	it[in2].weapon[0]+=stren/2; break;			default:	xlog("should never happen in soultrans_equipment()"); break;		}	}		it[in2].temp=0;	it[in2].flags|=IF_UPDATE|IF_IDENTIFIED|IF_NOREPAIR|IF_SOULSTONE;		it[in2].min_rank=max(it[in].data[0],it[in2].min_rank);	if (!it[in2].max_damage) it[in2].max_damage=60000;		souldestroy(cn,in);		sprintf(it[in2].description,"A %s enhanced by a rank %d soulstone.",it[in2].name,it[in].data[0]);}

/** * Identify the protocol to use from the request header * @return a proto_t value if defined/found, -1 otherwise */static int get_http_protocol(request_t *req){        char *ptr, *ptr2;        ptr2 = strstr(req->data, CRLF);        if(!ptr2)                goto invalid_http_protocol;        /* Move to beginning of URL */        for(ptr=req->data; ptr && *ptr!=' ' && *ptr!='/x00' && ptr < ptr2; ptr++);        if(!ptr || *ptr!=' ')                goto invalid_http_protocol;        ++ptr;        if(*ptr=='/'){                /* this indicates that the request is well formed already */                /* this case would happen only when using transparent mode */                return TRANSPARENT;        }        if( strncmp(ptr, HTTP_PROTO_STRING, sizeof(HTTP_PROTO_STRING)-1)==0 ){                /* Check if the requested URL starts with 'http://' */                req->http_infos.proto_type = HTTP;                return HTTP;        } else if( strncmp(ptr, HTTPS_PROTO_STRING, sizeof(HTTPS_PROTO_STRING)-1)==0 ){                /* Check if the requested URL starts with 'https://' */                req->http_infos.proto_type = HTTPS;                return HTTPS;        } else if( strncmp(ptr, WS_PROTO_STRING, sizeof(WS_PROTO_STRING)-1)==0 ){                /* Check if the requested URL starts with 'WS://' */                req->http_infos.proto_type = WS;                return WS;        }invalid_http_protocol:        xlog(LOG_ERROR, "%s/n", "Request is not a valid HTTP(S)/WS(S) request");        if (cfg->verbose > 1)                xlog(LOG_ERROR, "The invalid request is:/n%s/n", req);        return -1;}

void rtsp_tcp_read_cb(struct ev_loop *loop, ev_io *w,                      ATTR_UNUSED int revents){    guint8 buffer[RTSP_BUFFERSIZE + 1] = { 0, };    /* +1 to control the final '/0' */    int read_size;    RTSP_Client *rtsp = w->data;    int sd = rtsp->sd;    /* if we're receiving data for an HTTP tunnel, we have to run it       through the HTTP client's buffer. */    if ( rtsp->pair != NULL )        rtsp = rtsp->pair->http_client;    if ( (read_size = recv(sd,                           buffer,                           sizeof(buffer),                           0) ) <= 0 )        goto client_close;    stats_account_read(rtsp, read_size);    if (rtsp->input->len + read_size > RTSP_BUFFERSIZE) {        xlog(LOG_DBG,                "RTSP buffer overflow (input RTSP message is most likely invalid)./n");        goto server_close;    }    g_byte_array_append(rtsp->input, (guint8*)buffer, read_size);    xlog(LOG_DBG, "rtsp request probe is %d. localhost:%s remote:%s", rtsp->pending_request, rtsp->local_host, rtsp->remote_host);    RTSP_handler(rtsp);    return; client_close:    xlog(LOG_INF, "RTSP connection closed by client.");    goto disconnect; server_close:    xlog(LOG_INF, "RTSP connection closed by server.");    goto disconnect; disconnect:    ev_unloop(loop, EVUNLOOP_ONE);}

LVAL xlc_log(void){    double arg1 = getflonum(xlgaflonum());    double result;    xllastarg();    result = xlog(arg1);    return cvflonum(result);}

char * redis_dir_to_namespace(char *s, char cho, char chn) {	char *s_base = s;	xlog("redis_dir_to_namespace", "s=%s cho=%c chn=%c/n", s, cho, chn);	if(!s) return NULL;	while(*s) {		xlog("WTF", "%c/n", *s);		if(*s == cho)			*s = chn;		s++;	}	xlog("BUF", "%s/n", s);	return s_base;}

/** * Fill buflen-sized buffer with zeroes * * @param buf : buffer to zero-ize * @param buflen : buf length */void proxenet_xzero(void* buf, size_t buflen){	if (!buf) {		xlog(LOG_CRITICAL, "Trying to zero-ify NULL pointer %p/n", buf);		abort();	}	memset(buf, 0, buflen);}

int get_events(DC& container){        xlog("get_events");        GetEventSender sender;        container.for_each_active(TYPE_CAN,&sender);        return 0;}

/** * malloc(3) wrapper. Checks size and zero-fill buffer. * * Note: (re-)allocation is a "succeed-or-die" process in proxenet. * * @param size: buffer size to allocate on heap * @return ptr: allocated zero-filled buffer pointer */void* proxenet_xmalloc(size_t size){	void *ptr;	if (size > SIZE_MAX / sizeof(size_t)) {		xlog(LOG_CRITICAL, "proxenet_xmalloc: try to allocate incorrect size (%d byte)/n", size);		abort();	}	ptr = malloc(size);	if ( ptr == NULL ) {		xlog(LOG_CRITICAL, "%s/n", "proxenet_xmalloc: fail to allocate space");		abort();	}	proxenet_xzero(ptr, size);	return ptr;}

/** * This function is called when proxenet is loaded. Therefore, only the scripts * located in the `autoload_path` must be loaded. * Additionnal plugins can be added via the command line client. * * @return 0 on success * @return -1 on error */int proxenet_initialize_plugins_list(){        /* NULL as 2nd arg means to try to add all valid plugins from the path */        if(proxenet_add_new_plugins(cfg->autoload_path, NULL) < 0) {                xlog(LOG_CRITICAL, "%s/n", "Failed to build plugins list, leaving");                return -1;        }        if(cfg->verbose) {                xlog(LOG_INFO, "%s/n", "Plugins loaded");                if (cfg->verbose > 1) {                        xlog(LOG_INFO, "%d plugin(s) found/n", proxenet_plugin_list_size());                        proxenet_print_plugins_list(-1);                }        }        return 0;}

void count_chestboxes(void){        int x,y,in;        for (y=0; y<MAXMAP; y++) {                for (x=0; x<MAXMAP; x++) {                        if (!(in=map[x+y*MAXMAP].it)) continue;                        if (it[in].driver!=IDR_LAB5_ITEM || it[in].drdata[0]!=3) continue;                        it[in].drdata[2]=numchestboxes++;                }        }        if (numchestboxes>255) { xlog("too many chestboxes in lab5."); }        sizeofchestboxes=(numchestboxes+7)/8;        xlog("found %d chests in lab5 (%d bytes)",numchestboxes,sizeofchestboxes);}

static ssize_t proxenet_ioctl(ssize_t (*func)(), sock_t sock, void *buf, size_t count) {	int retcode = (*func)(sock, buf, count);	if (retcode < 0) {		xlog(LOG_ERROR, "Error while I/O plaintext data: %s/n", strerror(errno));		return -1;	}	return retcode;}

void get_windowed_ins_probs2(int win_length){	// Allocate two arrays for ins. prob over each window of length win_length over each sequence.	double* winned_ins_probs1 = (double*)malloc(sizeof(double) * global_aln_info.length1 - win_length + 1);	double* winned_ins_probs2 = (double*)malloc(sizeof(double) * global_aln_info.length2 - win_length + 1);	char win_ins_prob_file_name[100];	sprintf(win_ins_prob_file_name, "win_ins_probs1_%d.txt", win_length);	FILE* win_ins_prob_file = fopen(win_ins_prob_file_name, "w");	for(int cnt1 = 1; cnt1 < global_aln_info.length1 - win_length + 1; cnt1++)	{		// cnt1 is the index of starting of current window.		winned_ins_probs1[cnt1] = LOG_OF_ZERO;		// cnt2 is the index in second sequence where window is betweenm i.e., 		// the window is assumed to be inserted between cnt2 and cnt2 + 1.		// however I do not put the constraint that cnt1-1 is not aligned to cnt2 and cnt2 is not aligned to 		// cnt1 + win_length + 1.		for(int cnt2 = 1; cnt2 < global_aln_info.length2 + 1; cnt2++)		{			// cur_win_ins_prob includes probability of all enumerations of alignments where 			// currently set window is inserted in first sequences.			double cur_win_ins_prob	= xlog_mul(global_aln_info.fore_hmm_array->probs[cnt1][cnt2][STATE_INS1], global_aln_info.back_hmm_array->probs[cnt1 + win_length][cnt2][STATE_INS1]);						// Calculate the emission probability of inserted sequence by going over all inserted sequence.			// emit the nucleotides in the inserted sequence is sequence 1.			double int_emit_prob = xlog(1);			for(int emit_cnt = cnt1 + 1; emit_cnt <= cnt1 + win_length; emit_cnt++)			{				double trans_emit_prob;				if(emit_cnt == cnt1 + win_length)				{					trans_emit_prob = get_trans_emit_prob(STATE_INS1, STATE_INS1, emit_cnt, cnt2);				}				else				{					trans_emit_prob = get_trans_emit_prob(STATE_INS1, STATE_INS1, emit_cnt, cnt2);				}				int_emit_prob = xlog_mul(int_emit_prob, trans_emit_prob);			}			cur_win_ins_prob = xlog_mul(cur_win_ins_prob, int_emit_prob);			winned_ins_probs1[cnt1] = xlog_sum(winned_ins_probs1[cnt1], cur_win_ins_prob);					}			fprintf(win_ins_prob_file, "%f ", xlog_div(winned_ins_probs1[cnt1], global_aln_info.op_prob));	}	fprintf(win_ins_prob_file, "/n");	fclose(win_ins_prob_file);}

void *PhysicalMedium::run() {	pimpl->state = IDLE;	if (clock_gettime(pimpl->clockidToUse, &pimpl->curTime) == -1)		throw "clock_gettime: unrecoverable error";	do {		if (pimpl->state == IDLE) {			interval(1000);			if(pimpl->state == STOPPING)				break;			if (!pimpl->txList.empty())				pimpl->state = TX_802514_FRAME;			// Process CCA List			processCcaList();		}		// In this loop we wait until the Tx list is empty. During this		// time if we get more than 1 node in the Tx List we have a		// collision.		while (!pimpl->txList.empty()) {			// TODO: Maybe use timerfd to get finer resolution with			// Tx Packet Timings.			interval(1);			if(pimpl->state == STOPPING)				break;			// Process CCA List, as we are in state TX_802514_FRAME			// This routine will tell nodes they have failed CCA.			processCcaList();			// Check with subclasses collision check, this needs to			// be done before we check timeouts as if a tx timer			// expires it will check for collisions and arm the			// next packet to tx member variable.			txCollisionCheck();			// Go through Tx list and process timers and if one has			// expired send the Tx Done Indication with the result			// of the transmission.			processTxList();		}		if(pimpl->state != STOPPING) {			/* Check for nodes that have expired registration period */			pimpl->state = IDLE;			checkNodeRegistrationTimeout();		}	} while(pimpl->state != STOPPING);	xlog(LOG_NOTICE, "Network Simulator Stopped");	pimpl->state = STOPPED;	return 0;}