void launch_server() {
    int s = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in a;

    memset(&a, 0, sizeof(struct sockaddr_in));
    a.sin_family = AF_INET;
    a.sin_port = 0;
    if((a.sin_addr.s_addr = getPublicIPAddr()) == 0) {
	fprintf(stderr, "Could not get public ip address. Exiting...\n");
	exit(0);
    }

    if(mybind(s, &a) < 0) {
	fprintf(stderr, "mybind() failed. Exiting...\n");
	exit(0);
    }

    printf("%s %u\n", inet_ntoa(a.sin_addr), ntohs(a.sin_port));
    
    if(listen(s, 0) < 0) {
	perror("listen"); exit(0);
    }

    memset(&a, 0, sizeof(struct sockaddr_in));
    socklen_t alen = sizeof(struct sockaddr_in);
    int asock = -1;
    while((asock = accept(s, (struct sockaddr *)&a, &alen)) > 0) {
	/* Single-threaded */

	char *fname;
	int nparams;
	arg_type *a = NULL;
	return_type ret;

	recvCall(asock, &fname, &nparams, &a);

#ifdef _DEBUG_1_
	printf("launch_server(), before makeCall()\n"); fflush(stdout);
#endif

	makeCall(fname, nparams, a, &ret);

#ifdef _DEBUG_1_
	printf("launch_server(), after makeCall()\n"); fflush(stdout);
#endif

	returnResult(asock, &ret);

	free(fname);
	freeArgs(a);
	freeRet(ret);

	shutdown(asock, SHUT_RDWR); close(asock);
	asock = -1;
    }

    /* WARNING -- massive memory, linked list of registered
     * functions! We assume that the process exits at this
     * point, and so do not bother freeing the memory. */
    return;
}
示例#2
0
文件: macro.c 项目: xrg/RPM
/**
 * The main macro recursion loop.
 * @todo Dynamically reallocate target buffer.
 * @param mb		macro expansion state
 * @return		0 on success, 1 on failure
 */
static int
expandMacro(MacroBuf mb)
{
    rpmMacroEntry *mep;
    rpmMacroEntry me;
    const char *s = mb->s, *se;
    const char *f, *fe;
    const char *g, *ge;
    size_t fn, gn;
    char *t = mb->t;	/* save expansion pointer for printExpand */
    int c;
    int rc = 0;
    int negate;
    const char * lastc;
    int chkexist;

    if (++mb->depth > max_macro_depth) {
	rpmlog(RPMLOG_ERR,
		_("Recursion depth(%d) greater than max(%d)\n"),
		mb->depth, max_macro_depth);
	mb->depth--;
	mb->expand_trace = 1;
	return 1;
    }

    while (rc == 0 && mb->nb > 0 && (c = *s) != '\0') {
	s++;
	/* Copy text until next macro */
	switch(c) {
	case '%':
		if (*s) {	/* Ensure not end-of-string. */
		    if (*s != '%')
			break;
		    s++;	/* skip first % in %% */
		}
	default:
		SAVECHAR(mb, c);
		continue;
		break;
	}

	/* Expand next macro */
	f = fe = NULL;
	g = ge = NULL;
	if (mb->depth > 1)	/* XXX full expansion for outermost level */
		t = mb->t;	/* save expansion pointer for printExpand */
	negate = 0;
	lastc = NULL;
	chkexist = 0;
	switch ((c = *s)) {
	default:		/* %name substitution */
		while (strchr("!?", *s) != NULL) {
			switch(*s++) {
			case '!':
				negate = ((negate + 1) % 2);
				break;
			case '?':
				chkexist++;
				break;
			}
		}
		f = se = s;
		if (*se == '-')
			se++;
		while((c = *se) && (risalnum(c) || c == '_'))
			se++;
		/* Recognize non-alnum macros too */
		switch (*se) {
		case '*':
			se++;
			if (*se == '*') se++;
			break;
		case '#':
			se++;
			break;
		default:
			break;
		}
		fe = se;
		/* For "%name " macros ... */
		if ((c = *fe) && isblank(c))
			if ((lastc = strchr(fe,'\n')) == NULL)
                lastc = strchr(fe, '\0');
		break;
	case '(':		/* %(...) shell escape */
		if ((se = matchchar(s, c, ')')) == NULL) {
			rpmlog(RPMLOG_ERR,
				_("Unterminated %c: %s\n"), (char)c, s);
			rc = 1;
			continue;
		}
		if (mb->macro_trace)
			printMacro(mb, s, se+1);

		s++;	/* skip ( */
		rc = doShellEscape(mb, s, (se - s));
		se++;	/* skip ) */

		s = se;
		continue;
		break;
	case '{':		/* %{...}/%{...:...} substitution */
		if ((se = matchchar(s, c, '}')) == NULL) {
			rpmlog(RPMLOG_ERR,
				_("Unterminated %c: %s\n"), (char)c, s);
			rc = 1;
			continue;
		}
		f = s+1;/* skip { */
		se++;	/* skip } */
		while (strchr("!?", *f) != NULL) {
			switch(*f++) {
			case '!':
				negate = ((negate + 1) % 2);
				break;
			case '?':
				chkexist++;
				break;
			}
		}
		for (fe = f; (c = *fe) && !strchr(" :}", c);)
			fe++;
		switch (c) {
		case ':':
			g = fe + 1;
			ge = se - 1;
			break;
		case ' ':
			lastc = se-1;
			break;
		default:
			break;
		}
		break;
	}

	/* XXX Everything below expects fe > f */
	fn = (fe - f);
	gn = (ge - g);
	if ((fe - f) <= 0) {
/* XXX Process % in unknown context */
		c = '%';	/* XXX only need to save % */
		SAVECHAR(mb, c);
#if 0
		rpmlog(RPMLOG_ERR,
			_("A %% is followed by an unparseable macro\n"));
#endif
		s = se;
		continue;
	}

	if (mb->macro_trace)
		printMacro(mb, s, se);

	/* Expand builtin macros */
	if (STREQ("global", f, fn)) {
		s = doDefine(mb, se, RMIL_GLOBAL, 1);
		continue;
	}
	if (STREQ("define", f, fn)) {
		s = doDefine(mb, se, mb->depth, 0);
		continue;
	}
	if (STREQ("undefine", f, fn)) {
		s = doUndefine(mb->mc, se);
		continue;
	}

	if (STREQ("echo", f, fn) ||
	    STREQ("warn", f, fn) ||
	    STREQ("error", f, fn)) {
		int waserror = 0;
		if (STREQ("error", f, fn))
			waserror = 1;
		if (g != NULL && g < ge)
			doOutput(mb, waserror, g, gn);
		else
			doOutput(mb, waserror, f, fn);
		s = se;
		continue;
	}

	if (STREQ("trace", f, fn)) {
		/* XXX TODO restore expand_trace/macro_trace to 0 on return */
		mb->expand_trace = mb->macro_trace = (negate ? 0 : mb->depth);
		if (mb->depth == 1) {
			print_macro_trace = mb->macro_trace;
			print_expand_trace = mb->expand_trace;
		}
		s = se;
		continue;
	}

	if (STREQ("dump", f, fn)) {
		rpmDumpMacroTable(mb->mc, NULL);
		while (iseol(*se))
			se++;
		s = se;
		continue;
	}

#ifdef	WITH_LUA
	if (STREQ("lua", f, fn)) {
		rpmlua lua = NULL; /* Global state. */
		const char *ls = s+sizeof("{lua:")-1;
		const char *lse = se-sizeof("}")+1;
		char *scriptbuf = (char *)xmalloc((lse-ls)+1);
		const char *printbuf;
		memcpy(scriptbuf, ls, lse-ls);
		scriptbuf[lse-ls] = '\0';
		rpmluaSetPrintBuffer(lua, 1);
		if (rpmluaRunScript(lua, scriptbuf, NULL) == -1)
		    rc = 1;
		printbuf = rpmluaGetPrintBuffer(lua);
		if (printbuf) {
		    size_t len = strlen(printbuf);
		    if (len > mb->nb)
			len = mb->nb;
		    memcpy(mb->t, printbuf, len);
		    mb->t += len;
		    mb->nb -= len;
		}
		rpmluaSetPrintBuffer(lua, 0);
		free(scriptbuf);
		s = se;
		continue;
	}
#endif

	/* XXX necessary but clunky */
	if (STREQ("basename", f, fn) ||
	    STREQ("suffix", f, fn) ||
	    STREQ("expand", f, fn) ||
	    STREQ("verbose", f, fn) ||
	    STREQ("uncompress", f, fn) ||
	    STREQ("url2path", f, fn) ||
	    STREQ("u2p", f, fn) ||
	    STREQ("getenv", f, fn) ||
	    STREQ("S", f, fn) ||
	    STREQ("P", f, fn) ||
	    STREQ("F", f, fn)) {
		/* FIX: verbose may be set */
		doFoo(mb, negate, f, fn, g, gn);
		s = se;
		continue;
	}

	/* Expand defined macros */
	mep = findEntry(mb->mc, f, fn);
	me = (mep ? *mep : NULL);

	/* XXX Special processing for flags */
	if (*f == '-') {
		if (me)
			me->used++;	/* Mark macro as used */
		if ((me == NULL && !negate) ||	/* Without -f, skip %{-f...} */
		    (me != NULL && negate)) {	/* With -f, skip %{!-f...} */
			s = se;
			continue;
		}

		if (g && g < ge) {		/* Expand X in %{-f:X} */
			rc = expandT(mb, g, gn);
		} else
		if (me && me->body && *me->body) {/* Expand %{-f}/%{-f*} */
			rc = expandT(mb, me->body, strlen(me->body));
		}
		s = se;
		continue;
	}

	/* XXX Special processing for macro existence */
	if (chkexist) {
		if ((me == NULL && !negate) ||	/* Without -f, skip %{?f...} */
		    (me != NULL && negate)) {	/* With -f, skip %{!?f...} */
			s = se;
			continue;
		}
		if (g && g < ge) {		/* Expand X in %{?f:X} */
			rc = expandT(mb, g, gn);
		} else
		if (me && me->body && *me->body) { /* Expand %{?f}/%{?f*} */
			rc = expandT(mb, me->body, strlen(me->body));
		}
		s = se;
		continue;
	}
	
	if (me == NULL) {	/* leave unknown %... as is */
#ifndef HACK
#if DEAD
		/* XXX hack to skip over empty arg list */
		if (fn == 1 && *f == '*') {
			s = se;
			continue;
		}
#endif
		/* XXX hack to permit non-overloaded %foo to be passed */
		c = '%';	/* XXX only need to save % */
		SAVECHAR(mb, c);
#else
		rpmlog(RPMLOG_ERR,
			_("Macro %%%.*s not found, skipping\n"), fn, f);
		s = se;
#endif
		continue;
	}

	/* Setup args for "%name " macros with opts */
	if (me && me->opts != NULL) {
		if (lastc != NULL) {
			se = grabArgs(mb, me, fe, lastc);
		} else {
			addMacro(mb->mc, "**", NULL, "", mb->depth);
			addMacro(mb->mc, "*", NULL, "", mb->depth);
			addMacro(mb->mc, "#", NULL, "0", mb->depth);
			addMacro(mb->mc, "0", NULL, me->name, mb->depth);
		}
	}

	/* Recursively expand body of macro */
	if (me->body && *me->body) {
		mb->s = me->body;
		rc = expandMacro(mb);
		if (rc == 0)
			me->used++;	/* Mark macro as used */
	}

	/* Free args for "%name " macros with opts */
	if (me->opts != NULL)
		freeArgs(mb);

	s = se;
    }

    *mb->t = '\0';
    mb->s = s;
    mb->depth--;
    if (rc != 0 || mb->expand_trace)
	printExpansion(mb, t, mb->t);
    return rc;
}
示例#3
0
int main(int argc, char* argv[]) {
	
    // Parse command line arguments, use defaults when needed
    ArgumentStruct* args;
    args = parseArguments(argc, argv);
    
    // Struct to store response from CURL
    MessageStruct response;    
    struct tm* lastUpdated = getTime(&response, args->url);
    
    // Preapre response for re-use
    freeResponse(response);
    
    // Get RSS feed from server
    if (args->update) {
        // If we're either not refetching the same URL, or it has updates
        if (args->ignoreTimestamp || fetchingNewURL(args) ||
            args->previouslyFetchedURL == NULL || timeDiff(&(args->lastUpdated), lastUpdated)) {
                
            if(get(&response, args->url)) {
                printf("ERROR : Could not find feed at %s\n", args->url);
                
                freeArgs(args);
                
                return 1;
            }
        
            // Write result out to file
            if(storeFeed(response, args->dataFile, args->tempDirectory)) {
                printf("ERROR : Writing response to file (Running again should fix this)\n");
                
                freeArgs(args);
                
                return 1;
            }
        }
        else {
            printf("No updates for feed : %s\n", args->url);
            freeArgs(args);
            
            return 0;
        }
    }
    
    
    
    // Create array of article sturctures
    RSSFeed* feed = NULL;
    feed = parseFeed(args);
    
    // Display feed
    displayFeed(feed, args);
    storeSettings(args, feed);
    
    // Free everything that has been dynamically allocated
    freeFeed(feed);
    freeResponse(response);
    freeArgs(args);
    
    return 0;
}
示例#4
0
/// \details Initialize a Command structure with default values, then
/// parse any command line arguments that were supplied to overwrite
/// defaults.
///
/// \param [in] argc the number of command line arguments
/// \param [in] argv the command line arguments array
Command parseCommandLine(int argc, char** argv)
{
   Command cmd;

   memset(cmd.potDir, 0, 1024);
   memset(cmd.potName, 0, 1024);
   memset(cmd.potType, 0, 1024);
   strcpy(cmd.potDir,  "pots");
   strcpy(cmd.potName, "\0"); // default depends on potType
   strcpy(cmd.potType, "funcfl");
   cmd.doeam = 0;
   cmd.nx = 20;
   cmd.ny = 20;
   cmd.nz = 20;
   cmd.xproc = 1;
   cmd.yproc = 1;
   cmd.zproc = 1;
   cmd.nSteps = 100;
   cmd.printRate = 10;
   cmd.dt = 1.0;
   cmd.lat = -1.0;
   cmd.temperature = 600.0;
   cmd.initialDelta = 0.0;
   cmd.relativeSkinDistance= 0.1;
   cmd.doHilbert = 0;

   // gpu-specific
   memset(cmd.method, 0, 1024);
   strcpy(cmd.method, "thread_atom");
   cmd.gpuAsync = 0;
   cmd.gpuProfile = 0;

   cmd.ljInterpolation = 0;
   cmd.spline = 0;

   int help=0;
   // add arguments for processing.  Please update the html documentation too!
   addArg("help",       'h', 0, 'i',  &(help),             0,             "print this message");
   addArg("potDir",     'd', 1, 's',  cmd.potDir,    sizeof(cmd.potDir),  "potential directory");
   addArg("potName",    'p', 1, 's',  cmd.potName,   sizeof(cmd.potName), "potential name");
   addArg("potType",    't', 1, 's',  cmd.potType,   sizeof(cmd.potType), "potential type (funcfl or setfl)");
   addArg("doeam",      'e', 0, 'i',  &(cmd.doeam),        0,             "compute eam potentials");
   addArg("nx",         'x', 1, 'i',  &(cmd.nx),           0,             "number of unit cells in x");
   addArg("ny",         'y', 1, 'i',  &(cmd.ny),           0,             "number of unit cells in y");
   addArg("nz",         'z', 1, 'i',  &(cmd.nz),           0,             "number of unit cells in z");
   addArg("xproc",      'i', 1, 'i',  &(cmd.xproc),        0,             "processors in x direction");
   addArg("yproc",      'j', 1, 'i',  &(cmd.yproc),        0,             "processors in y direction");
   addArg("zproc",      'k', 1, 'i',  &(cmd.zproc),        0,             "processors in z direction");
   addArg("nSteps",     'N', 1, 'i',  &(cmd.nSteps),       0,             "number of time steps");
   addArg("printRate",  'n', 1, 'i',  &(cmd.printRate),    0,             "number of steps between output");
   addArg("dt",         'D', 1, 'd',  &(cmd.dt),           0,             "time step (in fs)");
   addArg("lat",        'l', 1, 'd',  &(cmd.lat),          0,             "lattice parameter (Angstroms)");
   addArg("temp",       'T', 1, 'd',  &(cmd.temperature),  0,             "initial temperature (K)");
   addArg("delta",      'r', 1, 'd',  &(cmd.initialDelta), 0,             "initial delta (Angstroms)");
   addArg("hilbert",    'H', 0, 'd',  &(cmd.doHilbert), 0,             "space-filling curve for the traversal of cells");
   addArg("skinDistance",'S', 1, 'd',  &(cmd.relativeSkinDistance), 0,     "skinDistance (relative to cutoff (default: 0.1))");
   addArg("method",  'm', 1, 's',  cmd.method, sizeof(cmd.method), "thread_atom,warp_atom,warp_atom_nl,cta_cell,thread_atom_nl,cpu_nl");

   // gpu-specific
   addArg("gpuAsync",   'a', 1, 'i',  &(cmd.gpuAsync),     0,             "communicaton hiding optimization using streams");
   addArg("gpuProfile", 's', 0, 'i',  &(cmd.gpuProfile),   0,             "profiling mode: reboxing disabled, single kernel run");
   addArg("ljInterpolation", 'I', 0, 'i', &(cmd.ljInterpolation), 0,   "compute Lennard-Jones potential using interpolation (gpu only)");
   addArg("spline", 'P', 0, 'i', &(cmd.spline), 0, "use splines for interpolation (gpu only)");
   addArg("usePairlist", 'L', 0, 'i', &(cmd.usePairlist), 0, "use pairlists for cta_cell method in Lennard-Jones computation");

   processArgs(argc,argv);

   // If user didn't set potName, set type dependent default.
   if (strlen(cmd.potName) == 0) 
   {
      if (strcmp(cmd.potType, "setfl" ) == 0)
         strcpy(cmd.potName, "Cu01.eam.alloy");
      if (strcmp(cmd.potType, "funcfl") == 0)
         strcpy(cmd.potName, "Cu_u6.eam");
   }
      
   if (help)
   {
      printArgs();
      freeArgs();
      exit(2);
   }
   freeArgs();

   return cmd;
}
示例#5
0
JNIEXPORT jobject JNICALL Java_gnu_rrd_RRDJNI_info
(JNIEnv *env, jclass cl, jobjectArray argv) {
  char      **argv2;
  rrd_info_t    *info, *save;

  jclass        HashtableClass;
  jmethodID     HashtableMethodInit;
  jmethodID     HashtableMethodPut;
  jclass        RRDInfoClass;
  jmethodID     RRDInfoMethodVal;
  jmethodID     RRDInfoMethodCnt;
  jmethodID     RRDInfoMethodStr;
  jmethodID     RRDInfoMethodDate;
  jclass        DateClass;
  jmethodID     DateMethodInit;
  jobject       DateObj;

  jobject       rtnObj;
  jstring       key;
  jdouble       value;
  jlong         counter;
  jstring       strval;
  
  HashtableClass      = (*env)->FindClass(env, "java/util/Hashtable");
  HashtableMethodInit = (*env)->GetMethodID(env, HashtableClass, "<init>", "()V");
  HashtableMethodPut  = (*env)->GetMethodID(env, HashtableClass, "put",
					    "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
  RRDInfoClass        = (*env)->FindClass(env, "gnu/rrd/RRDInfo");
  RRDInfoMethodVal    = (*env)->GetMethodID(env, RRDInfoClass, "<init>", "(D)V");
  RRDInfoMethodCnt    = (*env)->GetMethodID(env, RRDInfoClass, "<init>", "(J)V");
  RRDInfoMethodStr    = (*env)->GetMethodID(env, RRDInfoClass, "<init>", "(Ljava/lang/String;)V");
  RRDInfoMethodDate   = (*env)->GetMethodID(env, RRDInfoClass, "<init>", "(Ljava/util/Date;)V");
  DateClass           = (*env)->FindClass(env, "java/util/Date");
  DateMethodInit      = (*env)->GetMethodID(env, DateClass, "<init>", "(J)V");
  rtnObj              = (*env)->NewObject(env, HashtableClass, HashtableMethodInit, NULL);

  argv2 = initArgs(env, argv, "last");
  info = rrd_info((*env)->GetArrayLength(env, argv)+1, argv2);

  while (info) {
    save=info;
    key = (jstring)(*env)->NewStringUTF(env, info->key);
    switch (info->type) {
      case RD_I_VAL:
        value = info->value.u_val;
        (*env)->CallVoidMethod(env, rtnObj, HashtableMethodPut, key,
          (*env)->NewObject(env, RRDInfoClass, RRDInfoMethodVal, value), NULL);
        break;
      case RD_I_CNT:
	counter = info->value.u_cnt;
	if (strcmp(info->key, "last_update")==0) {
          (*env)->CallVoidMethod(env, rtnObj, HashtableMethodPut, key,
            (*env)->NewObject(env, RRDInfoClass, RRDInfoMethodDate,
	      (*env)->NewObject(env, DateClass, DateMethodInit, counter*1000)), NULL);
	} else {
          (*env)->CallVoidMethod(env, rtnObj, HashtableMethodPut, key,
            (*env)->NewObject(env, RRDInfoClass, RRDInfoMethodCnt, counter), NULL);
	}
        break;
      case RD_I_STR:
        strval = (jstring)(*env)->NewStringUTF(env, info->value.u_str);
        (*env)->CallVoidMethod(env, rtnObj, HashtableMethodPut, key,
          (*env)->NewObject(env, RRDInfoClass, RRDInfoMethodStr, strval), NULL);
        break;
    }
    info = info->next;
    free(save);
  }
  free(info);
  freeArgs(env, argv, argv2);
  if (rrd_test_error())
    throwException(env, "gnu/rrd/RRDException", rrd_get_error());

  return rtnObj;
}
示例#6
0
JNIEXPORT jobject JNICALL Java_gnu_rrd_RRDJNI_fetch
(JNIEnv *env, jclass cl, jobjectArray argv) {
  time_t        start, end;
  unsigned long step, ds_cnt, i, ii;
  rrd_value_t   *data, *datai;
  char          **ds_namv;
  char          s[30];
  char          **argv2;
  
  jclass        VectorClass;
  jmethodID     VectorMethodInit;
  jmethodID     VectorMethodAdd;
  jclass        DateClass;
  jmethodID     DateMethodInit;
  jclass        DoubleClass;
  jmethodID     DoubleMethodInit;
  jclass        RRDRecClass;
  jmethodID     RRDRecMethodInit;
  
  jobject       dateObj;
  jdouble       dataObj;
  jobject       dsObj;
  jobject       rtnObj;
  jlong         timestamp;
    
  VectorClass      = (*env)->FindClass(env, "java/util/Vector");
  VectorMethodInit = (*env)->GetMethodID(env, VectorClass, "<init>", "()V");
  VectorMethodAdd  = (*env)->GetMethodID(env, VectorClass, "addElement", "(Ljava/lang/Object;)V");
  DateClass        = (*env)->FindClass(env, "java/util/Date");
  DateMethodInit   = (*env)->GetMethodID(env, DateClass, "<init>", "(J)V");
  DoubleClass      = (*env)->FindClass(env, "java/lang/Double");
  DoubleMethodInit = (*env)->GetMethodID(env, DoubleClass, "<init>", "(D)V");
  RRDRecClass      = (*env)->FindClass(env, "gnu/rrd/RRDRec");
  RRDRecMethodInit = (*env)->GetMethodID(env, RRDRecClass, "<init>", "(Ljava/util/Date;Ljava/util/Vector;)V");
  rtnObj           = (*env)->NewObject(env, VectorClass, VectorMethodInit, NULL);

  argv2 = initArgs(env, argv, "fetch");
  if (rrd_fetch((*env)->GetArrayLength(env, argv)+1, argv2, &start, &end, &step,
      &ds_cnt, &ds_namv, &data) != -1) {
    datai = data;
    for (i = start; i <= end; i += step) {
      timestamp = i;
      dateObj = (*env)->NewObject(env, DateClass, DateMethodInit, timestamp*1000);
      dsObj   = (*env)->NewObject(env, VectorClass, VectorMethodInit, NULL);
      for (ii = 0; ii < ds_cnt; ii++) {
	dataObj = *(datai++);
        (*env)->CallVoidMethod(env, dsObj, VectorMethodAdd,
          (*env)->NewObject(env, DoubleClass, DoubleMethodInit, dataObj));
      }
      (*env)->CallVoidMethod(env, rtnObj, VectorMethodAdd,
        (*env)->NewObject(env, RRDRecClass, RRDRecMethodInit, dateObj, dsObj));
    }
    for (i=0; i<ds_cnt; i++) free(ds_namv[i]);
    free(ds_namv);
    free(data);
  }
  freeArgs(env, argv, argv2);
  if (rrd_test_error())
    throwException(env, "gnu/rrd/RRDException", rrd_get_error());

  return rtnObj;
}
示例#7
0
文件: josh.c 项目: sbeef/josh
// p2
// given a command and argument (in form args), forks and execs the call to shell.
// performs redirects, backgrounding and piping as given.
void p2(struct args *arguments){
  FILE *input, *output;
  /*while (NULL != args[len])
    len++;*/
  child = fork();
  if (-1 == child){
    perror("Fork failed");
    exit(EXIT_FAILURE);
  }
  if (child){
    int status;
    if  (arguments->background)
      waitpid(-1, &status, WNOHANG);
    else {
      //printf("fg\n");
      //signal(SIGINT, sigHandler);
      waitpid(-1, &status, WCONTINUED);
      freeArgs(arguments);
    }
  }
  else {
    int pipebool = 0;
    if (arguments->in_redir) {
      input = fopen(arguments->in_file, "r");
      dup2(fileno(input), STDIN_FILENO);
      fclose(input);
    }
    if (arguments->out_redir) {
      output = fopen(arguments->out_file, "w");
      dup2(fileno(output), STDOUT_FILENO);
      fclose(output);
    }
    if (NULL != arguments->pipe_args[0] && arguments->pipe_args[0][0] == '|') {  
      char ***b = pipearg(arguments);    
      pipebool = 1;
      char *s = arguments->pipe_args[0];
      int i, numpipe;
      i = numpipe = 0;
      while( s != NULL ){                           // count number of pipes
        if(strcmp(s,"|") == 0)
          numpipe++;
        i++;
        s = arguments->pipe_args[i];
      }
      piper(b,numpipe);
      
      /*pid_t forkChild;
      int fd[2];
      pipe(fd);

      forkChild = fork();
      if(-1 == forkChild){
  	perror("Fork failed");
  	exit(EXIT_FAILURE);
      }
      else if(forkChild == 0){            // Before pipe
  	close(fd[0]);
        dup2(fd[1], STDOUT_FILENO);                                    // Change child's input to tunnel output
  	close(fd[1]);
        execvp(arguments->program, arguments->program_args);                                         // Executes child's program
      }
      else{                // After pipe
        close(fd[1]);                                                   // Close unnecessary parent input link to tunnel
        dup2(fd[0], STDIN_FILENO);                                     // Change parent's output to tunnel input
  	close(fd[0]);
        char *cprog = arguments->pipe_args[1];                       // Name child's program
        char **cpargs;                                                // Initialize child's program arguments
        int i = 0;
        while(NULL != arguments->pipe_args[i+1])                     // Get number of child's program arguments (terminating NULL included)
          i++;
        cpargs = malloc(sizeof(char *) * (i + 1));
        for (int j = 0; j < i; j++) {                                 // Fill child's program args
          int len = strlen(arguments->pipe_args[j+1]) + 1;
          cpargs[j] = malloc(sizeof(char) * len);
          allocCheck(cpargs[j]);
          strncpy(cpargs[j], arguments->pipe_args[j+1], len);
        }
        cpargs[i] = NULL;
        execvp(cprog,cpargs);                                         // Executes child's program
        string_array_free(cpargs);
      }*/
    }
    if(pipebool == 0)
      execvp(arguments->program, arguments->program_args);
    if (errno) {
      perror("Exec failed");
      freeArgs(arguments);
    //argFree(args);
    //exit(EXIT_FAILURE);
    }
  }
}
/// \details Initialize a Command structure with default values, then
/// parse any command line arguments that were supplied to overwrite
/// defaults.
///
/// \param [in] argc the number of command line arguments
/// \param [in] argv the command line arguments array
Command parseCommandLine(int argc, char** argv)
{
   Command cmd;

   memset(cmd.potDir, 0, 1024);
   memset(cmd.potName, 0, 1024);
   memset(cmd.potType, 0, 1024);
   strcpy(cmd.potDir,  "pots");
   strcpy(cmd.potName, "\0"); // default depends on potType
   strcpy(cmd.potType, "funcfl");
   cmd.doeam = 0;
   cmd.nx = 20;
   cmd.ny = 20;
   cmd.nz = 20;
   cmd.xproc = 1;
   cmd.yproc = 1;
   cmd.zproc = 1;
   cmd.nSteps = 100;
   cmd.printRate = 10;
   cmd.dt = 1.0;
   cmd.lat = -1.0;
   cmd.temperature = 600.0;
   cmd.initialDelta = 0.0;

   int help=0;
   // add arguments for processing.  Please update the html documentation too!
   addArg("help",       'h', 0, 'i',  &(help),             0,             "print this message");
   addArg("potDir",     'd', 1, 's',  cmd.potDir,    sizeof(cmd.potDir),  "potential directory");
   addArg("potName",    'p', 1, 's',  cmd.potName,   sizeof(cmd.potName), "potential name");
   addArg("potType",    't', 1, 's',  cmd.potType,   sizeof(cmd.potType), "potential type (funcfl or setfl)");
   addArg("doeam",      'e', 0, 'i',  &(cmd.doeam),        0,             "compute eam potentials");
   addArg("nx",         'x', 1, 'i',  &(cmd.nx),           0,             "number of unit cells in x");
   addArg("ny",         'y', 1, 'i',  &(cmd.ny),           0,             "number of unit cells in y");
   addArg("nz",         'z', 1, 'i',  &(cmd.nz),           0,             "number of unit cells in z");
   addArg("xproc",      'i', 1, 'i',  &(cmd.xproc),        0,             "processors in x direction");
   addArg("yproc",      'j', 1, 'i',  &(cmd.yproc),        0,             "processors in y direction");
   addArg("zproc",      'k', 1, 'i',  &(cmd.zproc),        0,             "processors in z direction");
   addArg("nSteps",     'N', 1, 'i',  &(cmd.nSteps),       0,             "number of time steps");
   addArg("printRate",  'n', 1, 'i',  &(cmd.printRate),    0,             "number of steps between output");
   addArg("dt",         'D', 1, 'd',  &(cmd.dt),           0,             "time step (in fs)");
   addArg("lat",        'l', 1, 'd',  &(cmd.lat),          0,             "lattice parameter (Angstroms)");
   addArg("temp",       'T', 1, 'd',  &(cmd.temperature),  0,             "initial temperature (K)");
   addArg("delta",      'r', 1, 'd',  &(cmd.initialDelta), 0,             "initial delta (Angstroms)");

   processArgs(argc,argv);

   // If user didn't set potName, set type dependent default.
   if (strlen(cmd.potName) == 0) 
   {
      if (strcmp(cmd.potType, "setfl" ) == 0)
         strcpy(cmd.potName, "Cu01.eam.alloy");
      if (strcmp(cmd.potType, "funcfl") == 0)
         strcpy(cmd.potName, "Cu_u6.eam");
   }
      
   if (help)
   {
      printArgs();
      freeArgs();
      exit(2);
   }
   freeArgs();

   return cmd;
}
示例#9
0
CmsRet oal_spawnProcess(const SpawnProcessInfo *spawnInfo, SpawnedProcessInfo *procInfo)
{
   char **argv=NULL;
   SINT32 pid, i;
   CmsRet ret=CMSRET_SUCCESS;

   if ((ret = parseArgs(spawnInfo->exe, spawnInfo->args, &argv)) != CMSRET_SUCCESS)
   {
      return ret;
   }

   pid = fork();
   if (pid == 0)
   {
      SINT32 devNullFd=-1, fd;

      /*
       * This is the child.
       */

      /*
       * If user gave us specific instructions on fd re-routing,
       * do it before execv.
       */
      if ((spawnInfo->stdinFd == -1) ||
          (spawnInfo->stdoutFd == -1) ||
          (spawnInfo->stderrFd == -1)) {
         devNullFd = open("/dev/null", O_RDWR);
         if (devNullFd == -1)
         {
            cmsLog_error("open of /dev/null failed");
            exit(-1);
         }
      }

      if (spawnInfo->stdinFd != 0)
      {
         close(0);
         fd = (spawnInfo->stdinFd == -1) ? devNullFd : spawnInfo->stdinFd;
         dup2(fd, 0);
      }

      if (spawnInfo->stdoutFd != 1)
      {
         close(1);
         fd = (spawnInfo->stdoutFd == -1) ? devNullFd : spawnInfo->stdoutFd;
         dup2(fd, 1);
      }

      if (spawnInfo->stderrFd != 2)
      {
         close(2);
         fd = (spawnInfo->stderrFd == -1) ? devNullFd : spawnInfo->stderrFd;
         dup2(fd, 2);
      }

      if (devNullFd != -1)
      {
         close(devNullFd);
      }

      /* if child has a serverFd, dup it to the fixed number */
      if (spawnInfo->serverFd != -1)
      {
         close(CMS_DYNAMIC_LAUNCH_SERVER_FD);         
         dup2(spawnInfo->serverFd, CMS_DYNAMIC_LAUNCH_SERVER_FD);
      }

#if defined(AEI_VDSL_CUSTOMER_NCS)
#ifdef SUPPORT_HTTPD_SSL
      /* httpd second listen fd, dup it if necessary to the fixed number also */
	 if (spawnInfo->eid == EID_HTTPD || spawnInfo->eid == EID_HTTPSD)
	  {
	      if (spawnInfo->serverFd2 != -1)
	      {
	         close(CMS_DYNAMIC_LAUNCH_SERVER_FD2);         
	         dup2(spawnInfo->serverFd2, CMS_DYNAMIC_LAUNCH_SERVER_FD2);
	      }
	  }
#endif
#endif
      /* close all of the child's other fd's */
      for (i=3; i <= spawnInfo->maxFd; i++)
      {
#if defined(AEI_VDSL_CUSTOMER_NCS) && defined(SUPPORT_HTTPD_SSL)
         if (i == CMS_DYNAMIC_LAUNCH_SERVER_FD || i == CMS_DYNAMIC_LAUNCH_SERVER_FD2)
#else
         if (i == CMS_DYNAMIC_LAUNCH_SERVER_FD)
#endif
  //       if ((spawnInfo->serverFd != -1)  &&
    //         (i == CMS_DYNAMIC_LAUNCH_SERVER_FD))
         {
            continue;
         }
         close(i);
      }

      /*
       * Set all signal handlers back to default action,
       * in case the parent had set them to SIG_IGN or something.
       * See kernel/linux/include/asm-mips/signal.h
       */
      signal(SIGHUP, SIG_DFL);
      if (spawnInfo->inheritSigint == FALSE)
      {
         /*
          * Note: there is a bug in pthread library in the 4.4.2 toolchain
          * which breaks SIG_IGN inheritance.  Apps are advised to set
          * SIGINT handler explicitly in the app itself.
          */
         signal(SIGINT, SIG_DFL);
      }
      signal(SIGQUIT, SIG_DFL);
      signal(SIGILL, SIG_DFL);
      signal(SIGTRAP, SIG_DFL);
      signal(SIGABRT, SIG_DFL);  /* same as SIGIOT */
#ifndef DESKTOP_LINUX
      signal(SIGEMT, SIG_DFL);
#endif
      signal(SIGFPE, SIG_DFL);
      signal(SIGBUS, SIG_DFL);
      signal(SIGSEGV, SIG_DFL);
      signal(SIGSYS, SIG_DFL);
      signal(SIGPIPE, SIG_DFL);
      signal(SIGALRM, SIG_DFL);
      signal(SIGTERM, SIG_DFL);
      signal(SIGUSR1, SIG_DFL);
      signal(SIGUSR2, SIG_DFL);
      signal(SIGCHLD, SIG_DFL);  /* same as SIGCLD */
      signal(SIGPWR, SIG_DFL);
      signal(SIGWINCH, SIG_DFL);
      signal(SIGURG, SIG_DFL);
      signal(SIGIO, SIG_DFL);    /* same as SIGPOLL */
      signal(SIGSTOP, SIG_DFL);
      signal(SIGTSTP, SIG_DFL);
      signal(SIGCONT, SIG_DFL);
      signal(SIGTTIN, SIG_DFL);
      signal(SIGTTOU, SIG_DFL);
      signal(SIGVTALRM, SIG_DFL);
      signal(SIGPROF, SIG_DFL);
      signal(SIGXCPU, SIG_DFL);
      signal(SIGXFSZ, SIG_DFL);


      /* overlay child executable over myself */
      execv(spawnInfo->exe, argv);

      /* We should not reach this line.  If we do, exec has failed. */
      exit(-1);
   }

   /* this is the parent */

   freeArgs(argv); /* don't need these anymore */

   memset(procInfo, 0, sizeof(SpawnedProcessInfo));
   procInfo->pid = pid;
   procInfo->status = PSTAT_RUNNING;

   if (spawnInfo->spawnMode == SPAWN_AND_WAIT)
   {
      CollectProcessInfo collectInfo;

      collectInfo.collectMode = COLLECT_PID_TIMEOUT;
      collectInfo.pid = pid;
      collectInfo.timeout = spawnInfo->timeout;

      ret = oal_collectProcess(&collectInfo, procInfo);
      if (ret == CMSRET_TIMED_OUT)
      {
         CmsRet r2;

         cmsLog_debug("pid %d has not exited in %d ms, SIGKILL", spawnInfo->timeout);
         r2 = oal_signalProcess(pid, SIGKILL);
         if (r2 != CMSRET_SUCCESS)
         {
            cmsLog_error("SIGKILL to pid %d failed with ret=%d", pid, r2);
         }

         /* try one more time to collect it */
         collectInfo.collectMode = COLLECT_PID_TIMEOUT;
         collectInfo.pid = pid;
         collectInfo.timeout = COLLECT_WAIT_INTERVAL_MS;
         r2 = oal_collectProcess(&collectInfo, procInfo);
         if (r2 == CMSRET_SUCCESS)
         {
            /* we finally go it, otherwise, leave ret at CMSRET_TIMED_OUT */
            ret = CMSRET_SUCCESS;
         }
      }
      else if (ret != CMSRET_SUCCESS)
      {
         /* some other error with collect */
         cmsLog_error("Could not collect pid %d", pid);
      }
   }

   return ret;
}
示例#10
0
/** Give a single string, allocate and fill in an array of char *'s
 * each pointing to an individually malloc'd buffer containing a single
 * argument in the string; the array will end with a char * slot containing NULL.
 *
 * This array can be passed to execv.
 * This array must be freed by calling freeArgs.
 */
CmsRet parseArgs(const char *cmd, const char *args, char ***argv)
{
   UINT32 numArgs=3, i, len, argIndex=0;
   UBOOL8 inSpace=TRUE;
   const char *cmdStr;
   char **array;

   len = (args == NULL) ? 0 : strlen(args);

   /*
    * First count the number of spaces to determine the number of args
    * there are in the string.
    */
   for (i=0; i < len; i++)
   {
      if ((args[i] == ' ') && (!inSpace))
      {
         numArgs++;
         inSpace = TRUE;
      }
      else
      {
         inSpace = FALSE;
      }
   }

   array = (char **) cmsMem_alloc((numArgs) * sizeof(char *), ALLOC_ZEROIZE);
   if (array == NULL)
   {
      return CMSRET_RESOURCE_EXCEEDED;
   }

   /* locate the command name, last part of string */
   cmdStr = strrchr(cmd, '/');
   if (cmdStr == NULL)
   {
      cmdStr = cmd;
   }
   else
   {
      cmdStr++;  /* move past the / */
   }

   /* copy the command into argv[0] */
   array[argIndex] = cmsMem_alloc(strlen(cmdStr) + 1, ALLOC_ZEROIZE);
   if (array[argIndex] == NULL)
   {
      cmsLog_error("malloc of %d failed", strlen(cmdStr) + 1);
      freeArgs(array);
      return CMSRET_RESOURCE_EXCEEDED;
   }
   else
   {
      strcpy(array[argIndex], cmdStr);
      argIndex++;
   }


   /*
    * Wow, this is going to be incredibly messy.  I have to malloc a buffer
    * for each arg and copy them in individually.
    */
   inSpace = TRUE;
   for (i=0; i < len; i++)
   {
      if ((args[i] == ' ') && (!inSpace))
      {
         numArgs++;
         inSpace = TRUE;
      }
      else if ((args[i] != ' ') && (inSpace))
      {
            UINT32 startIndex, endIndex;

            /*
             * this is the first character I've seen after a space.
             * Figure out how many letters this arg is, malloc a buffer
             * to hold it, and copy it into the buffer.
             */
            startIndex = i;
            endIndex = i;
            while ((endIndex < len) && (args[endIndex] != ' '))
            {
               endIndex++;
            }

            array[argIndex] = cmsMem_alloc(endIndex - startIndex + 1, ALLOC_ZEROIZE);
            if (array[argIndex] == NULL)
            {
               cmsLog_error("malloc of %d failed", endIndex - startIndex + 1);
               freeArgs(array);
               return CMSRET_RESOURCE_EXCEEDED;
            }

            memcpy(array[argIndex], &args[startIndex], endIndex - startIndex);
            /*
            cmsLog_debug("index=%d len=%d (%s)", argIndex, endIndex - startIndex, &args[startIndex]);
            */

            argIndex++;

            inSpace = FALSE;
      }
   }

   /* check what we did */
   i = 0;
   while (array[i] != NULL)
   {
      cmsLog_debug("argv[%d] = %s", i, array[i]);
      i++;
   }

   (*argv) = array;


   return CMSRET_SUCCESS;
}
示例#11
0
int main(int argc, char *argv[])
{
  FILE * file;
  int i, indirectCount, indirectNode;
  int zoneCount = 0;
  int partitionOffset = 0;

  SUPERBLOCK *diskinfo;
  INODE *node, *tempNode;
  DIRECT *direct;
  ARGSP *argsp;

  diskinfo = malloc(sizeof(SUPERBLOCK));
  node = malloc(sizeof(INODE));
  tempNode = malloc(sizeof(INODE));
  direct = malloc(sizeof(DIRECT));
  argsp = malloc(sizeof(ARGSP));

  /* Grab Args */
  getArgs(argsp, argc, argv);  
  if(argsp->hflag) {
    printUsage();
    exit(1);
  }
  
  /* Open File */
  file = fopen(argsp->image, "r");
  if (file == NULL) {
    perror("Some Error:");
    exit (1);
  }

  /* Grab Partition offset */
  if((partitionOffset = getPartition(file, argsp)) < 0) {
    fputs("Bad partition\n",stderr);
    exit(1);
  }  

  /* Grab node for file */
  if(!(node = minInitialize(file, diskinfo, argsp, partitionOffset))) {
    fputs("File not found\n",stderr);
    exit(1);
  }
  
    
  /* current node should be the matching diretory or file */
  if((node->mode & FILEMASK & DIRECTORYMASK)) {

    zoneCount = 0; 
    indirectCount = 0;  

    printf("%s:\n", argsp->path);    
    fseek(file, partitionOffset + diskinfo->zonesize 
      * node->zone[zoneCount], SEEK_SET);

    for(i = 0; i < node->size / sizeof(DIRECT); i++) {
      fread(direct, sizeof(DIRECT), 1, file);

      if(direct->inode) {
        getNode(tempNode, file, diskinfo, direct->inode, partitionOffset);
        printItem(tempNode, direct->name);
      }

      /* check to see if we are at the end of a zone 
         and need to move to next zone*/
      if(((i+1) * sizeof(DIRECT) % diskinfo->zonesize) == 0) {

        if (zoneCount < REGULAR_ZONES-1) {
          zoneCount++;
          fseek(file, partitionOffset + diskinfo->zonesize 
            * node->zone[zoneCount], SEEK_SET);
        } else {
        
          /* jump to indirect block plus offset */
          fseek(file, partitionOffset + diskinfo->zonesize 
            * node->zoneindirect 
            + (sizeof(uint32_t) * indirectCount), SEEK_SET);
          indirectCount++;
          
          /* grab new zone value */
          fread(&indirectNode, sizeof(uint32_t), 1, file);           
          
          /* set filepointer to new indirect zone */
          fseek(file, partitionOffset +  diskinfo->zonesize 
            * indirectNode, SEEK_SET);
        }
      }
      
    }
  } else {
    printItem(node, argsp->path);
  }
      
  freeArgs(argsp);
  free(argsp);
  free(direct);
  free(tempNode);
  free(node);
  free(diskinfo);
  fclose(file);
  
  exit(0);
}
示例#12
0
int main(void) {
	signal(SIGINT, intHandler);
	char *command = NULL, *filePath = NULL;
	char **args = NULL;
	node *root = NULL;
	fd_set rfds;
	struct timeval tv;
	int retval;
	
	while(run) {
		tv.tv_sec = 1;
		tv.tv_usec = 0;
		FD_ZERO(&rfds);
		FD_SET(0, &rfds);
		int retval = select(1, &rfds, NULL, NULL, &tv);
		
		if(retval == -1) { 
			printf("\nShutting Down\n\n");
			return 0;
		}else if(retval == 0) {
			continue;
		}
		
		args = getInput();
		if(args == NULL) {
			fflush(stdin);
			continue;
		}
		
		root = collapseFilePath(args[0]);
		
		if(root == NULL) {
			freeArgs(args);
			continue;
		}
		
		filePath = getValidFilePath(root);
		
		if(filePath == NULL) {
			freePath(root);
			freeArgs(args);
			continue;
		}
		
		char *data = parseData(args[1]);
		if(data == NULL) {
			freePath(root);
			freeArgs(args);
			free(filePath);
			continue;
		}
		
		command = (char *) malloc(strlen(filePath) + strlen(data) + 18);
		if(command == NULL) {
			printf("ERROR: Not enough memory to malloc the echo command\n");
		}else {
			strncpy(command, "echo ", 6);
			strncat(command, "\"", 3);
			strncat(command, data, strlen(data)+1);
			strncat(command, "\"", 3);
			strncat(command, " >> ", 5);
			strncat(command, "\"", 3);
			strncat(command, filePath, strlen(filePath)+1);
			strncat(command, "\"", 3);
			
			
			//printf("Command:\n");
			//printf("%s\n", command);
			int result = system(command);
			if(result == -1) {
				printf("ERROR: Could not append to file\n");
			}
			printf("SUCCESS\n");
		}
		
		free(data);
		free(command);
		free(filePath);
		freePath(root);
		freeArgs(args);
	}
    
	if(command != NULL) free(command);
	if(filePath != NULL) free(filePath);
	if(root != NULL) freePath(root);
	if(args != NULL) freeArgs(args);
    return 0;
}
示例#13
0
int PV_Arguments::resetState(int argc, char * argv[], bool allowUnrecognizedArguments) {
   int status = clearState();
   pvAssert(status == PV_SUCCESS);
   freeArgs(numArgs, args); args = NULL;
   return initialize(argc, argv, allowUnrecognizedArguments);
}