Beispiel #1
0
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;
}
Beispiel #7
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.
 */
int
from_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;
}
Beispiel #8
0
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;
}
Beispiel #9
0
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);
}
Beispiel #11
0
/**
 * 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];
}
Beispiel #12
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");
	}
}
Beispiel #13
0
/*
 * 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 int
svc_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;
}
Beispiel #14
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;
}
Beispiel #15
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. */
void
PhysicalMedium::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);
}
Beispiel #16
0
/**
 * 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;
}
Beispiel #17
0
/**
 * 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;
}
Beispiel #18
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]);
}
Beispiel #19
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);
}
Beispiel #21
0
LVAL xlc_log(void)
{
    double arg1 = getflonum(xlgaflonum());
    double result;

    xllastarg();
    result = xlog(arg1);
    return cvflonum(result);
}
Beispiel #22
0
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;
}
Beispiel #23
0
/**
 * 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);
}
Beispiel #24
0
int get_events(DC& container)
{
        xlog("get_events");

        GetEventSender sender;
        container.for_each_active(TYPE_CAN,&sender);

        return 0;
}
Beispiel #25
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;
}
Beispiel #26
0
/**
 * 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;
}
Beispiel #27
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);
}
Beispiel #28
0
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);
}
Beispiel #30
0
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;
}