/* Functions. */
void inetConnect()
{
	pid_t cpid;
	char *argv[] = { "/usr/bin/wvdial", NULL };

	while( 1 )
	{
		LOG( "Forking a new process to execute wvdial." );
		cpid = fork();
		if( cpid < 0 )
		{
			LOG( strerror( errno ) );
			LOG( "Sleeping ", FORKDELAY, " seconds and retrying." );
			sleep( FORKDELAY );
		}
		else if( !cpid )
		{
			int nullfd;
			LOG( "Child: Redirecting STDOUT and STDERR to /dev/null." );
			if( ( nullfd = open( "/dev/null", O_WRONLY ) ) < 0 )
			{
				LOG( strerror( errno ) );
				LOG( "Child: Could not open /dev/null for writing. Skipping redirction.");
			}
			else
			{
				LOG( "Child: Redirecting STDERR." );
				if( dup2( nullfd, STDERR_FILENO ) < 0 )
				{
					LOG( strerror( errno ) );
				}
				LOG( "Child: Redirecting STDOUT." );
				if( dup2( nullfd, STDOUT_FILENO ) < 0 )
				{
					LOG( strerror( errno ) );
				}
			}	
			LOG( "Child: Executing wvdial." );
			execv( argv[ 0 ], argv );
			LOG( strerror( errno ) );
			LOG( "Child: Looping" );
		}
		else
		{
			LOG( "Parent: Monitoring internet connection." );
			sleep( CHECKDELAY );
			while( isconnected() )
				sleep( CHECKDELAY );
			LOG( "Parent: No internet connection is found. Sending wvdial a SIGTERM." );
			if( kill( cpid, SIGTERM ) < 0 )
				LOG( strerror( errno ) );
			waitpid( cpid, NULL, 0 );
			LOG( "Parent: wvdial process died, looping." );
		}
		sleep( CONNECTIONDELAY );
	}

	LOG( "Program flow is not support to reach here. Exiting." );
	return;
}
void endsocket(void)
{
	if(isconnected())
		shutdown(sock->socket,2);

	closesocket(sock->socket);
	if(sock->buf != NULL)
		bufferevent_free(sock->buf);
	event_base_loopbreak(sock->base);
	_sleep(500); //wait for libevent loop to break before unloading base.
	event_base_free(sock->base);
	libevent_global_shutdown();
	WSACleanup();
	free(sock);
}
int main()
{
	int i,j,cnt=0;
	char t;
	scanf("%d%d",&n,&m);
	getchar();
	for (i=1;i<=n;i++)
	{
		for (j=1;j<=m;j++)
		{
			scanf("%c",&t);
			if (t=='#')
			{
				mp[i][j]=true;
				cnt++;
			}
		}
		getchar();
	}
	if (cnt<=2)
	{
		printf("-1");
		return 0;
	}
	for (i=1;i<=n;i++)
		for (j=1;j<=m;j++)
			if (mp[i][j])
			{
				mp[i][j]=false;
				if (!isconnected())
				{
					printf("1");
					return 0;
				}
				mp[i][j]=true;
			}
	printf("2");
	return 0;
}
Exemple #4
0
static void
genextend(graph *g, int n2, int *deg, int ne, boolean rigid, int xlb, int xub)
/* extend from n2 to n2+1 */
{
    int x,y,d;
    int *xorb,xc;
    int nx,i,j,imin,imax,dmax;
    int xlbx,xubx,n;
    graph gx[MAXN];
    int degx[MAXN];
    boolean rigidx;
    int dneed,need,nfeet,hideg,deg1,ft[MAXN],nfrag,frag[MAXN];

#ifdef INSTRUMENT
    boolean haschild;

    haschild = FALSE;
    ++nodes[n2];
    if (rigid) ++rigidnodes[n2];
#endif

    n = n1 + n2;
    nx = n2 + 1;
    dmax = deg[n-1];

    d = 0;
    dneed = mindeg1 - maxn2 + n2;
    need = 0;
    hideg = 0;
    deg1 = 0;
    for (i = 0; i < n1; ++i)
    {
        if (deg[i] == maxdeg1) d |= xbit[i];
        if (deg[i] <= dneed) need |= xbit[i];
        if (deg[i] >= 2) hideg |= xbit[i];
        if (deg[i] == 1) deg1 |= xbit[i];
    }

    if (xlb < XPOPCOUNT(need)) xlb = XPOPCOUNT(need);
    if (xlb > xub) return;

    imin = xstart[xlb];
    imax = xstart[xub+1];
    xorb = data[n2].xorb;

    if (nx == maxn2)
    {
        if (footfree)
        {
            nfeet = 0;
            for (j = 0; j < n2; ++j)
            {
                x = xval[j] & hideg;
                IFLE1BITS(x) ft[nfeet++] = xval[j] & deg1;
            }
        }
        if (cutfree) fragments(xval,n2,frag,&nfrag);

        for (i = imin; i < imax; ++i)
        {
            if (!rigid && xorb[i] != i) continue;
            x = xset[i];
            xc = xcard[i];
            if ((x & d) != 0) continue;
            if ((need & ~x) != 0) continue;

            if (simple)
            {
                for (j = n2; --j >= 0;)
                    if (x == xval[j]) break;
                if (j >= 0) continue;
            }
            if (maxcommon >= 0)
            {
                for (j = n2; --j >= 0;)
                {
                    y = x & xval[j];
                    if (XPOPCOUNT(y) > maxcommon) break;
                }
                if (j >= 0) continue;
            }
	    if (antichain)
	    {
		for (j = 0; j < n2; ++j)
		    if ((xval[j] & ~x) == 0) break;
		if (j < n2) continue;
	    }
            if (footfree)
            {
                y = x & (hideg | deg1);
                IFLE1BITS(y) continue;
                for (j = 0; j < nfeet; ++j)
                    if ((x & ft[j]) == 0) break;
                if (j < nfeet) continue;
            }
            if (cutfree)
            {
                y = x & (hideg | deg1);
                IFLE1BITS(y) continue;
                for (j = 0; j < nfrag; ++j)
                    if ((x & frag[j]) == 0) break;
                if (j < nfrag) continue;
            }

            xval[n2] = x;

            if (nx == nprune)
            {
                if (curres == 0) curres = mod;
#ifdef SPLITTEST
                --curres;
                ++splitcases;
                continue;
#else
                if (--curres != 0) continue;
#endif
            }
            if (accept2(g,n2,x,gx,deg,xc > dmax))
                if (!connec || isconnected(gx,n+1))
                {
                    ADDBIG(ecount[ne+xc],1);
#ifdef INSTRUMENT
                    haschild = TRUE;
#endif
                    (*outproc)(outfile,canonise ? gcan : gx,n1,n2+1);
                }
        }
    }
    else
    {
        for (i = imin; i < imax; ++i)
Exemple #5
0
int sock_connect( const char *addr) {

    struct sockaddr   peer;
    struct sockaddr *ppeer;
    int s;

#if HAVE_SELECT
    fd_set rdevents, wrevents, exevents;
    struct timeval tv;
    
    int flags;
    int rc;
#endif
    
    bzero( &peer,  sizeof (peer));

    if ( (ppeer = parse_addr( addr )) == NULL ) {
        return -1;
    }
    memcpy( &peer, ppeer, sizeof(peer) );

    s = socket( AF_INET, SOCK_STREAM, 0);
    if ( s < 0 ) {
        Perror("socket");
        return -1;
    }

#ifdef HAVE_SELECT    
    if ( (flags = fcntl(s, F_GETFL, 0)) < 0) {
        Perror("fcntl(s, F_GETFL, 0)");
        return -1;
    }

    if ( (flags = fcntl(s, F_SETFL, O_NONBLOCK)) < 0) {
        Perror("fcntl(s, F_SETFL, O_NONBLOCK)");
        return -1;
    }

    if ( (rc = connect(s, &peer, sizeof (peer))) && errno != EINPROGRESS ) {
#else
    if ( connect(s, &peer, sizeof (peer)) ) {
#endif
        Perror("connect");
        return -1;
    }
#ifdef HAVE_SELECT
    if ( rc == 0 ) {
        if ( fcntl(s, F_SETFL, flags) < 0 ) {
            Perror("fcntl");
            return -1;
        }
        debug("connected to %s", addr );
        return s;
    }

    FD_ZERO ( &rdevents );
    FD_SET ( s, &rdevents );

    wrevents = exevents = rdevents;

    tv.tv_sec = 5;
    tv.tv_usec = 0;

    rc = select( s + 1, &rdevents, &wrevents, &exevents, &tv); 
    if ( rc < 0 ) {
        Perror("select");
        return -1;
    }
    else if ( rc == 0 ) {
        error("timeout connecting to %s", addr );
        return -1;
    }
    else if ( isconnected(s, &rdevents, &wrevents, &exevents ) ) {
        if ( fcntl(s, F_SETFL, flags) < 0 ) {
            Perror("fcntl");
            return -1;
        }
        debug("connected to %s", addr );
        return s;
    }
    else {
        error("connection to %s failed", addr );
        return -1;
    }

    
#else
    debug("connected to %s", addr );
#endif 
    return s;
}

int sock_listen( const char *addr ) {
    int s;

    const int on = 1;

    struct sockaddr_in   local;
    struct sockaddr    *plocal;

    bzero( &local, sizeof (local));
    
    if ( (plocal = parse_addr(addr)) == NULL ) {
        return -1;
    }

    memcpy( &local, plocal, sizeof(local) );

    s = socket( AF_INET, SOCK_STREAM, 0 );

    if ( s < 0 ) {
        Perror("socket");
        return -1;
    }

    if ( setsockopt( s, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on))) {
        Perror("setsockopt");
        return -1;
    }
    
    if ( bind( s,  (struct sockaddr *)&local, sizeof(local) )) {
        Perror("bind");
        return -1;
    }

    if ( listen( s, 1 ) ) {
        Perror("listen");
        return -1;
    }

    notice("listening on %s", addr );

    return s;
}
Exemple #6
0
VARF(throttle_accel,    0, 2, 32, throttle());
VARF(throttle_decel,    0, 2, 32, throttle());

void throttle()
{
    if(!curpeer) return;
    ASSERT(ENET_PEER_PACKET_THROTTLE_SCALE==32);
    enet_peer_throttle_configure(curpeer, throttle_interval*1000, throttle_accel, throttle_decel);
}

bool isconnected(bool attempt)
{
    return curpeer || (attempt && connpeer);
}

ICOMMAND(isconnected, "i", (int *attempt), intret(isconnected(*attempt > 0) ? 1 : 0));

const ENetAddress *connectedpeer()
{
    return curpeer ? &curpeer->address : NULL;
}

ICOMMAND(connectedip, "", (),
{
    const ENetAddress *address = connectedpeer();
    string hostname;
    result(address && enet_address_get_host_ip(address, hostname, sizeof(hostname)) >= 0 ? hostname : "");
});

ICOMMAND(connectedport, "", (),
{
Exemple #7
0
char *
makegraph(char *iname)
{
    FILE *infile;
    Graph *G = NULL;
    char inbuf[LINE],outfilename[LINE];
    register char *cp;
    char *method;
    int count, lineno=0, numlevels, nerrors;
    int i, m=0, prefixlen;
    int edgeConnMeth, haux, stubsPerTrans, tsEdges, ssEdges;
    long seed;
    geo_parms	parmsbuf[MAXLEVEL];	/* make sure MAXLEVEL >= 3 */

    if ((infile = fopen(iname, "r")) == NULL) {
        sprintf(errstr, "can't open input file %s", iname);
        die(errstr);
    }

    /* set up output file name */

    sprintf(outfilename,"%s-",iname);
    prefixlen = strlen(outfilename);

    do {
        fgets(inbuf, LINE - 1, infile);
        lineno++;
        method = strtok(inbuf, delim);
    } while (((method == NULL) || (*method == '#'))
             && !feof(infile));
    /* skip over comments  and blank lines */

    if ((cp = strtok(NULL, delim))==NULL)
        return "missing <number of graphs>";

    count = atoi(cp);

    if ((cp = strtok(NULL, delim))==NULL)
        seed = 0;
    else
        seed = atol(cp);

    if (strcmp(method,GEO_KW)==0) {

        if (cp = get_geoparms(infile,parmsbuf))
            return cp;
        m = GEO;

    } else if (strcmp(method,HIER_KW)==0) {

        if (cp = get_hierparms(infile,
                               &numlevels, &edgeConnMeth, &haux, parmsbuf))
            return cp;
        m = HIER;

    } else if (strcmp(method,TS_KW)==0) {

        if (cp = get_tsparms(infile,
                             &stubsPerTrans, &tsEdges, &ssEdges, parmsbuf))
            return cp;
        m = TS;
    } else {
        sprintf(errstr,"Unknown generation method %s",method);
        return errstr;
    }


    if (seed)
        gb_init_rand(seed);
    else
        gb_init_rand(DEFAULT_SEED);

    for (i=0; i<count; i++) {
        sprintf(outfilename+prefixlen,"%d.gb",i);
        switch(m) {
        case GEO:
            do {
                gb_recycle(G);
                G = geo(0,parmsbuf);
            } while (G != NULL && !isconnected(G));
            break;
        case HIER:
            G = geo_hier(0,numlevels,edgeConnMeth,haux,parmsbuf);
            break;
        case TS:
            G = transtub(0,stubsPerTrans,tsEdges,ssEdges,&parmsbuf[0],
                         &parmsbuf[1],&parmsbuf[2]);
            break;
        default:
            return "This can't happen!";

        }	/* switch */

        if (G==NULL) {
            sprintf(errstr,"Error creating graph %d, trouble code=%d",i,
                    gb_trouble_code);
            return errstr;
        }

        nerrors = save_graph(G, outfilename);
        if (nerrors > 0)
            fprintf(stderr, "%s had %d anomalies\n", outfilename,nerrors);
        gb_recycle(G);
    }	/* for */

    return NULL;
}
void send_data(buffer_t *data)
{
	if(isconnected())
		socketsend(data);
}
Exemple #9
0
Graph *
geo_hier(long seed,
	int nlevels,	/* number of levels (=size of following array) */
	int edgemeth,	/* method of attaching edges */
	int aux,	/* auxiliary parameter for edge method (threshold) */
	geo_parms *pp)	/* array of parameter structures, one per level */
{
Graph *newG, *tG, *GG, *srcG, *dstG;
long *numv;		/* array of sizes of lower-level graphs */
geo_parms *curparms, workparms[MAXLEVEL];
register i,k,indx;
long dst;
int temp,total,lowsize,otherend,blen,level;
long maxP[MAXLEVEL], maxDiam[MAXLEVEL], wt[MAXLEVEL];
Vertex *np,*vp,*up,*base;
Arc *ap;
char vnamestr[MAXNAMELEN];


     if (seed)		/* convention: zero seed means don't use */
	gb_init_rand(seed);

     if (nlevels < 1 || nlevels > MAXLEVEL) {
	gb_trouble_code = bad_specs+HIER_TRBL;
	return NULL;
     }

     /* 1 <= nlevels <= MAXLEVEL */

     /* copy the parameters so we can modify them, and caller doesn't
      * see the changes.
      */
     for (level=0; level<nlevels; level++)
	bcopy((char *)&pp[level],&workparms[level],sizeof(geo_parms));

     level = 0;

     gb_trouble_code = 0;
     
     tG = NULL;
     do {
	gb_recycle(tG);
        tG = geo(0L,workparms);
     } while (tG != NULL && !isconnected(tG));

     if (tG==NULL)
	return tG;

     maxDiam[0] = fdiam(tG);
     maxP[0] = maxDiam[0];
     wt[0] = 1;

     for (i=1; i<nlevels; i++)
       maxDiam[i] = -1;

     curparms = workparms;

     while (++level < nlevels) {
       long tdiam;

	curparms++;	/* parameters for graphs @ next level */

        /* spread out the numbers of nodes per graph at this level */
	numv = (long *) calloc(tG->n,sizeof(long));
	lowsize = curparms->n;
        randomize(numv,tG->n,curparms->n,3*tG->n);

	/* create a subordinate graph for each vertex in the "top" graph,
         * and add it into the new graph as a whole.
	 * We construct the subgraphs all at once to ensure that each
	 * has a unique address.
	 */
	for (i=0,vp=tG->vertices; i<tG->n; i++,vp++) {
	    curparms->n = numv[i];
	    do {
		newG = geo(0L,curparms);
		if (newG==NULL) return NULL;
	    } while (!isconnected(newG));
	    vp->sub = newG;
	    tdiam = fdiam(newG);
	    if (tdiam>maxDiam[level])
	      maxDiam[level] = tdiam;
	}

	/* do some calculations before "flattening" the top Graph */

	total = 0;

	for (i=0; i<tG->n; i++) {	/* translate node numbers */
	    temp = numv[i];		
	    numv[i]= total;
	    total += temp;
	}

	if (total != tG->n*lowsize) {
	    fprintf(stderr,"bad size of new graph!\n");
	    fprintf(stderr,"total %d tG->n %ld lowsize %d\n",total,tG->n,lowsize);
	    gb_trouble_code = impossible+HIER_TRBL;
	    return NULL;
	}

	/* now create what will become the "new" top-level graph */
	newG = gb_new_graph(total);
	if (newG==NULL) {
	    gb_trouble_code += HIER_TRBL;
	    return NULL;
	}

	/* resolution of the new graph */
	newG->Gscale = tG->Gscale * curparms->scale;

       /* compute edge weights for this level */

       wt[level] = maxP[level-1] + 1;
       maxP[level] = (maxDiam[level]*wt[level])
	 + (maxDiam[level-1]*maxP[level-1]);

       for (i=0,vp=tG->vertices; i<tG->n; i++,vp++) {
	 strcpy(vnamestr,vp->name);	/* base name for all "offspring" */
	 blen = strlen(vnamestr);
	 vnamestr[blen] = '.';
	    
	 GG = tG->vertices[i].sub;
	 base = newG->vertices + numv[i];	/* start of this node's */
	 for (k=0,np=base,up=GG->vertices; k<GG->n; k++,np++,up++) {

	   /* add the node's edges */
	   for (ap=up->arcs; ap; ap=ap->next)  {
	     otherend = ap->tip - GG->vertices;
	     if (k < otherend)
	       gb_new_edge(np,base+otherend,ap->len);
	     
	   }

	   /* now set the new node's position */
	   np->xpos = tG->vertices[i].xpos * curparms->scale + up->xpos;
	   np->ypos = tG->vertices[i].ypos * curparms->scale + up->ypos;

	   /* give the "new" node a name by catenating top & bot names */
	   strcpy(vnamestr+blen+1,up->name);
	   np->name = gb_save_string(vnamestr);

	 } /* loop over GG's vertices */
       }  /* loop over top-level vertices */

       /*
	* Now we have to transfer the top-level edges to new graph.
	* This is done by one of three methods:
	*    0: choose a random node in each subgraph
	*    1: attach to the smallest-degree non-leaf node in each
	*    2: attach to smallest-degree node
	*    3: attach to first node with degree less than aux
	*/
       for (i=0; i<tG->n; i++) {
	 Vertex *srcp, *dstp;
	 Graph *srcG, *dstG;

	 srcG = tG->vertices[i].sub;

	 if (srcG == NULL) {	/* paranoia */
	   gb_trouble_code = impossible+HIER_TRBL+1;
	   return NULL;
	 }

	 for (ap=tG->vertices[i].arcs; ap; ap=ap->next) {

	   dst = ap->tip - tG->vertices;

	   if (i > dst)	/* consider each edge only ONCE */
	     continue;

	   dstG = ap->tip->sub;

	   if (dstG == NULL) {	/* paranoia */
	     gb_trouble_code = impossible+HIER_TRBL+1;
	     return NULL;
	   }

	   /* choose endpoints of the top-level edge */

	   switch (edgemeth) {
	   case 0:	/* choose random node in each */
	     srcp = srcG->vertices + gb_next_rand()%srcG->n;
	     dstp = dstG->vertices + gb_next_rand()%dstG->n;
	     break;

	   case 1:	/* find nonleaf node of least degree in each */
	     /* This causes problems with graph size < 3 */
	     if (srcG->n > 2)
	       srcp = find_small_deg(srcG,NOLEAF);
	     else
	       srcp = find_small_deg(srcG,LEAFOK);
	     if (dstG->n > 2)
	       dstp = find_small_deg(dstG,NOLEAF);
	     else
	       dstp = find_small_deg(dstG,LEAFOK);
	     break;

	   case 2: /* find node of smallest degree */
	     srcp = find_small_deg(srcG,LEAFOK);
	     dstp = find_small_deg(dstG,LEAFOK);
	     break;

	   case 3: /* first node w/degree < aux */
	     srcp = find_thresh_deg(srcG,aux);
	     dstp = find_thresh_deg(dstG,aux);
	   default:
	     gb_trouble_code = bad_specs+HIER_TRBL;
	     return NULL;

	   }	/* switch on edgemeth */

	   /* pointer arithmetic: isn't it fun?
	      printf("Copying edge from %d to %d\n",
	      numv[i]+(srcp - srcG->vertices),
	      numv[dst] + (dstp - dstG->vertices));
	      */
	   if (srcp==NULL || dstp==NULL) {
	     gb_trouble_code = impossible + HIER_TRBL+2;
	     return NULL;
	   }
		
	   srcp = newG->vertices + numv[i] + (srcp - srcG->vertices);
	   dstp = newG->vertices + numv[dst] + (dstp - dstG->vertices);

	   gb_new_edge(srcp,dstp,idist(srcp,dstp));

	 } /* for each arc */
       } /* for each vertex of top graph */

        /* now make the "new" graph the "top" graph and recycle others */
       for (i=0,vp=tG->vertices; i<tG->n; i++,vp++)
	 gb_recycle(vp->sub);

       gb_recycle(tG);

       tG = newG;

       free(numv);
     }	/* while more levels */

/* Finally, go back and add the policy weights,
 * based upon the computed max diameters
 * and Max Path lengths.
 */
   for (i=0; i<tG->n; i++)
     for (ap=tG->vertices[i].arcs; ap; ap=ap->next) {
       dst = ap->tip - tG->vertices;
       if (i > dst)	/* consider each edge only ONCE */
	 continue;

       assert(i != dst); /* no self loops */

       /* i < dst: it is safe to refer to ap's mate by ap+1.  */
       level = edge_level(&tG->vertices[i],&tG->vertices[dst],nlevels);
       ap->policywt = (ap+1)->policywt = wt[level];

     }

/* construct the utility and id strings for the new graph.
 * Space constraints will restrict us to keeping about 4 levels'
 * worth of info.
 */
  {
    char buf[ID_FIELD_SIZE+1];
    register char *cp;
    int len, nextlen, left;

    strcpy(tG->util_types,GEO_UTIL);	/* same for all geo graphs,	*/
					/* defined in geo.h		*/
    cp = tG->id;
    sprintf(cp,"geo_hier(%ld,%d,%d,%d,[",seed,nlevels,edgemeth,aux);
    len = strlen(cp);
    left = ID_FIELD_SIZE - len;
    cp += len;
    
    for (i=0; (i < nlevels) && (left > 0); i++) {
      nextlen = printparms(buf,&pp[i]);
      strncpy(cp,buf,left);
      left -= nextlen;
      cp += nextlen;
    }
    if (left > 0) {
      sprintf(buf,"])");
      nextlen = strlen(buf);
      strncpy(cp,buf,left);
    }
  }

  return tG;
}	/* geo_hier() */
/**************************** SUBROUTINES ******************************/
int main()
{
        int sfd, device_type, channel,num_of_3g;
        struct sockaddr_in saddr;
        socklen_t len;
	pthread_t wifi, threeg;
	char name[16];
	

        init_vrms_connection();
        init_logging_network_changes();	
#if 0
	while(1){

		send_vrms_data("wlan0", 5);
		printf("wlan0 sent\n");
		sleep(30);
		send_vrms_data("ppp1", 4);
		printf("ppp1 sent\n");
		sleep(22);
#if 0
		send_vrms_data("ppp1", 4);
		printf("wlan0 sent\n");
		sleep(30);
		send_vrms_data("ppp2", 4);
		printf("ppp2 sent\n");
		sleep(30);
#endif
		send_vrms_data("ppp2", 4);
		printf("ppp2 sent\n");
		sleep(20);
	}
#endif
	openlog("SeaMo:VHO", LOG_PID, LOG_DAEMON);

	/* Obtain a D-Bus connection handler for all D-Bus activities */
	conn = (DBusConnection *) get_connection();

        init_3g_connections();
	/* socket creation for communication with vrms. (earlier this was 
  	   done in get_current_network every time it was called which is not
 	   necessary)*/
 /* Connect to the available modems */
	connect_all_modems(conn); 
	/* Check if the system is currently connected to any network */
	while (!isconnected(conn)) {
		syslog(LOG_WARNING,
		       "Please connect to any available network\n");
		sleep(1);
	}
/*
	char *active_conn[30];
	get_active_conn(conn, active_conn);

	while (1) {
		syslog(LOG_INFO, "Inside while\n");
		int conn_state = get_active_conn_state(conn, *active_conn);
		if (conn_state == 0 || conn_state == -1)	//Unknown state
			syslog(LOG_ERR, "Not Connected to any network\n");
		else if (conn_state == CONNECTED)
			break;
		else if (conn_state == ACTIVATING)
			continue;
	}
*/
	system ("sh /usr/local/seamo/sbin/ip_rules_all.sh");	

	/* Create threads to receive data from pre-handoff */
	if (pthread_create(&threeg, NULL, threeg_data, NULL)) {
		syslog(LOG_ERR, "error in server threads\n");
	}
	if (pthread_create(&wifi, NULL, wifi_data, NULL)) {
		syslog(LOG_ERR, "error in server threads\n");
	}

	read_config();

	/* Get the signal when the parent process dies */
	prctl(PR_SET_PDEATHSIG, SIGHUP);


	while (1) {
		wifi_avail = wifi_param();

      	
                num_of_3g = get_num_of_modems(conn);
          
                if ( num_of_3g >=1){
               	threeg_avail = threeg_param();
                }
                
                else {
                   threeg_avail == -1 ;
                   }



		syslog(LOG_INFO, "wifi_avail: %d, threeg_avail: %d\n",
		       wifi_avail, threeg_avail);

		if (wifi_avail == 1 || threeg_avail == 1) {
			get_current_network(&device_type, name, &channel);

#ifdef DEBUG_L1
			syslog(LOG_INFO, "Current network: %s %d\n", name,
			       channel);
#endif

			/* If currently connected to Wi-Fi then keep the network
			 * under Observation. If the network conditions goes down
			 * then trigger the algorithm. But in case of 3G we dont 
			 * keep the network under observation, because 3G is assumed
			 * to be every where, the conditions of 3G will remain almost
			 * the same, hence we look for better Wi-Fi instead of waiting 
			 * for 3G network to degrade  */
			sleep(1);
			if (device_type == WIFI) {
				observe_wifi(name, channel);
				vho_trigger();
			} else if (device_type == GSM){
				observe_3g(name);
				vho_trigger();
			}
		}

		/* Check if parent process is alive */
		if (getppid() == 1)
			kill(getpid(), SIGHUP);
	}
	closelog();
	return 0;
}
Exemple #11
0
VARF(throttle_accel,    0, 2, 32, throttle());
VARF(throttle_decel,    0, 2, 32, throttle());

void throttle()
{
    if(!curpeer) return;
    ASSERT(ENET_PEER_PACKET_THROTTLE_SCALE==32);
    enet_peer_throttle_configure(curpeer, throttle_interval*1000, throttle_accel, throttle_decel);
}

bool isconnected(bool attempt, bool local)
{
    return curpeer || (attempt && connpeer) || (local && haslocalclients());
}

ICOMMAND(isconnected, "bb", (int *attempt, int *local), intret(isconnected(*attempt > 0, *local != 0) ? 1 : 0));

const ENetAddress *connectedpeer()
{
    return curpeer ? &curpeer->address : NULL;
}

ICOMMAND(connectedip, "", (),
{
    const ENetAddress *address = connectedpeer();
    string hostname;
    result(address && enet_address_get_host_ip(address, hostname, sizeof(hostname)) >= 0 ? hostname : "");
});

ICOMMAND(connectedport, "", (),
{