Esempio n. 1
0
static char *
readline(char **line, size_t *linesize, size_t *length, FILE *fp)
{
	int c;
	size_t n = 0;

	if (*line == NULL || *linesize < LSIZE + n + 1)
		*line = srealloc(*line, *linesize = LSIZE + n + 1);
	for (;;) {
		if (n >= *linesize - LSIZE / 2)
			*line = srealloc(*line, *linesize += LSIZE);
		c = getc(fp);
		if (c != EOF) {
			(*line)[n++] = c;
			(*line)[n] = '\0';
			if (c == '\n')
				break;
		} else {
			if (n > 0)
				break;
			else
				return NULL;
		}
	}
	*length = n;
	return *line;
}
Esempio n. 2
0
void *xrealloc(void *ptr,int size,int ID)
{
	struct mem_block *mem;

	if (ptr==NULL) return xcalloc(size,ID);

	mem=(void*)((char*)(ptr)-sizeof(struct mem_block));

	rem_block(mem);

#ifdef DEBUG
	mem=srealloc(mem,size+sizeof(struct mem_block)+32,ID);
#else
	mem=srealloc(mem,size+sizeof(struct mem_block),ID);
#endif
	if (!mem) return NULL;

	mem->size=size;
	mem->ID=ID;

#ifdef DEBUG
	memcpy(mem->magic,       "ABCDEFGHIJKLMNOPQRSTUVWXYZ012345",32);
	memcpy(mem->content+size,"abcdefghijklmnopqrstuvwxyz678901",32);
#endif

	add_block(mem);

	return mem->content;
}
Esempio n. 3
0
static void
addcmd(const char *s)
{
	if (a_cnt >= a_maxarg - 4096) {
		a_maxarg += 8192;
		a_vec = srealloc(a_vec, a_maxarg * sizeof *a_vec);
	}
	if (iflag && contains(s, iflag)) {
		if (replcnt >= replsiz) {
#ifdef	WEIRD_LIMITS
			if (replcnt >= 5) {
				fprintf(stderr, "%s: too many args with %s\n",
					progname, iflag);
				exit(1);
#endif	/* WEIRD_LIMITS */
			replpos = srealloc(replpos,
					(replsiz += 5) * sizeof *replpos);
		}
		replpos[replcnt++] = a_cnt;
	}
	a_vec[a_cnt++] = s;
	a_asz += strlen(s) + 1;
}

static void
endcmd(void)
{
	a_agg = a_cnt;
	a_maxsize = sysconf(_SC_ARG_MAX) - envsz() - 2048 - a_asz;
	if (nflag || sflag) {
		long	newsize = sflag ? atol(sflag) :
#ifdef	WEIRD_LIMITS
			LINE_MAX;
#else	/* !WEIRD_LIMITS */
			a_maxsize;
#endif	/* !WEIRD_LIMITS */
		if (sflag && (newsize <= a_asz || newsize > a_maxsize))
			fprintf(stderr,
				"%s: 0 < max-cmd-line-size <= %ld: -s%s\n",
				progname, a_maxsize, sflag);
		if (newsize < a_maxsize)
			a_maxsize = newsize;
	}
	if (sflag)
		a_spc = smalloc(a_maxsize);
	else {
		while ((a_spc = malloc(a_maxsize)) == NULL) {
			a_maxsize /= 2;
			if (a_maxsize < LINE_MAX) {
				a_spc = smalloc(a_maxsize);
				break;
			}
		}
	}
	a_cur = a_agg;
	if (nflag && nflag < a_maxarg + a_cnt) {
		nflag += a_cnt;
		a_maxarg = nflag;
	}
}
Esempio n. 4
0
static int new_return_error(struct rtrn** ret, const char* err, int arg)
{
    int r=-2;
    int i=0;
    const char** tmpv;
    int* tmparg;
    while ((*ret)->errsv[i++]);
    (*ret)->errsc=i;
    tmpv = srealloc((*ret)->errsv, (sizeof *(*ret)->errsv)*(i+1));
    if (tmpv)
    {
        r++;
        (*ret)->errsv=tmpv;
        (*ret)->errsv[i-1]=err;
        (*ret)->errsv[i]=NULL;
    }
    tmparg = srealloc((*ret)->errsarg, (sizeof *(*ret)->errsarg)*i);
    if (tmparg)
    {
        r++;
        (*ret)->errsarg=tmparg;
        (*ret)->errsarg[i-1]=arg;
    }
    return r;
}
Esempio n. 5
0
static char *printer_add_enum(int param, char *buffer,
                              int offset, int *nprinters_ptr)
{
    DWORD needed, nprinters;

    buffer = srealloc(buffer, offset+512);

    /*
     * Exploratory call to EnumPrinters to determine how much space
     * we'll need for the output. Discard the return value since it
     * will almost certainly be a failure due to lack of space.
     */
    EnumPrinters(param, NULL, ENUM_LEVEL, buffer+offset, 512,
		 &needed, &nprinters);

    if (needed < 512)
        needed = 512;

    buffer = srealloc(buffer, offset+needed);

    if (EnumPrinters(param, NULL, ENUM_LEVEL, buffer+offset,
                     needed, &needed, &nprinters) == 0)
        return NULL;

    *nprinters_ptr += nprinters;

    return buffer;
}
Esempio n. 6
0
unsigned vector_grow(DV_Vector* dv)
{
	unsigned old_max = dv->size_hint;
	dv->size_hint *= 2;
	dv->data = srealloc(dv->data, 
			    dv->chunk_size * dv->size_hint);
	dv->indices = srealloc(dv->indices, sizeof(unsigned) * dv->size_hint);
	memset(dv->indices+old_max, 0, sizeof(unsigned)*old_max);
	return dv->size_hint - old_max;
}
Esempio n. 7
0
void mat_resize(Matrix *m, int nrows, int ncols) {
  int i;
  if (!(nrows >= 0 && ncols >= 0))
    die("ERROR mat_resize: nrows=%i ncols=%i\n", nrows, ncols);
  for (i = nrows; i < m->nrows; i++) sfree(m->data[i]);
  m->data = srealloc(m->data, nrows * sizeof(void*));
  for (i = 0; i < nrows; i++)
    m->data[i] = srealloc(m->data[i], ncols * sizeof(double));      
  m->nrows = nrows;
  m->ncols = ncols;
}
Esempio n. 8
0
/* read in a tree from a file.  Return character string
   representing tree */
SEXP rph_tree_read(SEXP filename) {
  FILE *infile;
  char c;
  SEXP result;
  char *currStr, **strvec;
  int i, pos=0, currLen=10000, numparen=0, numtrees_alloc=1000, numtrees=0;

  infile = phast_fopen(CHARACTER_VALUE(filename), "r");
  currStr = smalloc((currLen+2)*sizeof(char));
  strvec = smalloc(numtrees_alloc*sizeof(char*));
  while (1) {
    pos=0;
    numparen=0;
    while (';'!=(c=fgetc(infile))) {
      if (c==EOF) {
	if (pos==0) break;
	die("unexpected EOF in tree file.  Trees should be terminated by \";\"");
      }
      if (isspace(c)) continue;
      if (c=='(') numparen++;
      if (c==')') numparen--;
      if (numparen < 0) die("bad tree in tree file");
      if (pos==currLen) {
	currLen += 10000;
	currStr = srealloc(currStr, (currLen+2)*sizeof(char));
      }
      currStr[pos++] = c;
    }
    if (pos > 0) {
      if (numparen != 0) die("unbalanced parenthesis in tree file");
      currStr[pos++]=';';
      currStr[pos]='\0';
      if (numtrees == numtrees_alloc) {
	numtrees_alloc += 1000;
	strvec = srealloc(strvec, numtrees_alloc*sizeof(char*));
      }
      strvec[numtrees] = smalloc((strlen(currStr)+1)*sizeof(char));
      strcpy(strvec[numtrees], currStr);

      numtrees++;
    }
    else break;
  }
  phast_fclose(infile);
  PROTECT(result = NEW_CHARACTER(numtrees));
  for (i=0; i<numtrees; i++)
    SET_STRING_ELT(result, i, mkChar(strvec[i]));
  UNPROTECT(1);
  return result;
}
Esempio n. 9
0
static int give_value(const char* val, struct option* opt)
{
    int r=0;
    unsigned short i=0;
    if (opt->takes_value == 1)
    {
        free(opt->value);
        opt->value = smalloc((sizeof *opt->value) * (strlen(val)+1));
        if (opt->value)
            strcpy(opt->value, val);
        else
            r=-1;
    }
    else
    {
        char** tmp;
        while (opt->valuev[i++]);
        tmp = srealloc(opt->valuev, (sizeof *opt->valuev)*(i+1));
        if (tmp)
        {
            opt->valuev=tmp;
            (opt->valuev)[i-1] = smalloc((sizeof *(opt->valuev)[i-1]) * (strlen(val)+1));
            if ((opt->valuev)[i-1])
                strcpy((opt->valuev)[i-1], val);
            else
                r=-1;
            (opt->valuev)[i]=NULL;
            opt->valuec=i;
        }
        else
            r=-1;
    }
    return r;
}
Esempio n. 10
0
static bool opensex_read_next_row(database_handle_t *hdl)
{
	int c = 0;
	unsigned int n = 0;
	opensex_t *rs = (opensex_t *)hdl->priv;

	while ((c = getc(rs->f)) != EOF && c != '\n')
	{
		rs->buf[n++] = c;
		if (n == rs->bufsize)
		{
			rs->bufsize *= 2;
			rs->buf = srealloc(rs->buf, rs->bufsize);
		}
	}
	rs->buf[n] = '\0';
	rs->token = rs->buf;

	if (c == EOF && ferror(rs->f))
	{
		slog(LG_ERROR, "opensex-read-next-row: error at %s line %d: %s", hdl->file, hdl->line, strerror(errno));
		slog(LG_ERROR, "opensex-read-next-row: exiting to avoid data loss");
		exit(EXIT_FAILURE);
	}

	if (c == EOF && n == 0)
		return false;

	hdl->line++;
	hdl->token = 0;
	return true;
}
Esempio n. 11
0
int split_buf(char *buf, char ***argv, int colon_special)
{
    int argvsize = 8;
    int argc;
    char *s;

    *argv = scalloc(sizeof(char *) * argvsize, 1);
    argc = 0;
    while (*buf) {
        if (argc == argvsize) {
            argvsize += 8;
            *argv = srealloc(*argv, sizeof(char *) * argvsize);
        }
        if (*buf == ':') {
            (*argv)[argc++] = buf + 1;
            buf = "";
        } else {
            s = strpbrk(buf, " ");
            if (s) {
                *s++ = 0;
                while (*s == ' ')
                    s++;
            } else {
                s = buf + strlen(buf);
            }
            (*argv)[argc++] = buf;
            buf = s;
        }
    }
    return argc;
}
Esempio n. 12
0
void add_file(unsigned long long mult, char *name) {
	unsigned int i;
	file_t *file = NULL;
	char *buffer = NULL;

	// find matching entry in file_list
	for (i=0; i < file_list_len; i++) {
		file = &(file_list[i]);
		if (strcmp(file->name, name) == 0) {
			// is mult a multiple of file->mult?
			if (mult % file->mult == 0)
				return;
			// is file->mult a multiple of mult?
			if (file->mult % mult == 0) {
				file->mult = mult;
				return;
			}
			buffer = file->buffer;
		}
	}

	// no buffer for file found?
	if (!buffer)
		buffer = (char *) smalloc(buflen);

	// add new entry
	file_list_len++;
	file_list = (file_t *) srealloc((void *) file_list, sizeof(file_t) * file_list_len);
	file = &(file_list[file_list_len - 1]);
	file->mult = mult;
	file->name = (char *) smalloc(strlen(name) + 1);
	strcpy(file->name, name);
	file->buffer = buffer;
}
Esempio n. 13
0
static void xmlrpc_command_success_nodata(sourceinfo_t *si, const char *message)
{
    connection_t *cptr;
    struct httpddata *hd;
    char *p;
    const char *q;

    cptr = si->connection;
    hd = cptr->userdata;
    if (hd->sent_reply)
        return;
    if (hd->replybuf != NULL)
    {
        hd->replybuf = srealloc(hd->replybuf, strlen(hd->replybuf) + strlen(message) + 2);
        p = hd->replybuf + strlen(hd->replybuf);
        *p++ = '\n';
    }
    else
    {
        hd->replybuf = smalloc(strlen(message) + 1);
        p = hd->replybuf;
    }
    q = message;
    while (*q != '\0')
        if (*q > '\0' && *q < ' ')
            q++;
        else
            *p++ = *q++;
    *p = '\0';
}
Esempio n. 14
0
inline int FindTimerSpace() {
	for (int i = 0; i<numTimers; i++) {
		if (timers[i].type == KILLED_TIMER) return i;
	}
	if (!srealloc(timers, sizeof(ScriptTimer) * (numTimers+1))) return -1;
	return numTimers ++;
}
Esempio n. 15
0
void string::set_length(int i)
{
  assert(i >= 0);
  if (i > sz)
    ptr = srealloc(ptr, sz, len, i, &sz);
  len = i;
}
Esempio n. 16
0
void addtest(void *elem) {
    int i, j;
    void *retval, *realret;

    if (arraysize < arraylen+1) {
        arraysize = arraylen+1+256;
        array = (array == NULL ? smalloc(arraysize*sizeof(*array)) :
                 srealloc(array, arraysize*sizeof(*array)));
    }

    i = 0;
    while (i < arraylen && cmp(elem, array[i]) > 0)
        i++;
    /* now i points to the first element >= elem */
    if (i < arraylen && !cmp(elem, array[i]))
        retval = array[i];             /* expect that returned not elem */
    else {
        retval = elem;                  /* expect elem returned (success) */
        for (j = arraylen; j > i; j--)
            array[j] = array[j-1];
        array[i] = elem;                /* add elem to array */
        arraylen++;
    }

    realret = add234(tree, elem);
    if (realret != retval) {
        error("add: retval was %p expected %p", realret, retval);
    }

    verify();
}
Esempio n. 17
0
File: psftp.c Progetto: rdebath/sgt
static int sftp_cmd_lcd(struct sftp_command *cmd)
{
    char *currdir;
    int len;

    if (cmd->nwords < 2) {
	printf("lcd: expects a local directory name\n");
	return 0;
    }

    if (!SetCurrentDirectory(cmd->words[1])) {
	LPVOID message;
	int i;
	FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
		      FORMAT_MESSAGE_FROM_SYSTEM |
		      FORMAT_MESSAGE_IGNORE_INSERTS,
		      NULL, GetLastError(),
		      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
		      (LPTSTR)&message, 0, NULL);
	i = strcspn((char *)message, "\n");
	printf("lcd: unable to change directory: %.*s\n", i, (LPCTSTR)message);
	LocalFree(message);
	return 0;
    }

    currdir = smalloc(256);
    len = GetCurrentDirectory(256, currdir);
    if (len > 256)
	currdir = srealloc(currdir, len);
    GetCurrentDirectory(len, currdir);
    printf("New local directory is %s\n", currdir);
    sfree(currdir);

    return 1;
}
Esempio n. 18
0
static void opl_append(struct oplist *o, enum optype type)
{
	if (o->len == o->size)
	{
		o->size += o->size >> 1;
		o->ops = srealloc(o->ops, o->size * sizeof *o->ops);
	}
Esempio n. 19
0
static void xmlrpc_command_success_nodata(sourceinfo_t *si, const char *message)
{
	connection_t *cptr;
	struct httpddata *hd;
	char *newmessage;
	char *p;

	newmessage = xmlrpc_normalizeBuffer(message);

	cptr = si->connection;
	hd = cptr->userdata;
	if (hd->sent_reply)
	{
		free(newmessage);
		return;
	}
	if (hd->replybuf != NULL)
	{
		hd->replybuf = srealloc(hd->replybuf, strlen(hd->replybuf) + strlen(newmessage) + 2);
		p = hd->replybuf + strlen(hd->replybuf);
		*p++ = '\n';
	}
	else
	{
		hd->replybuf = smalloc(strlen(newmessage) + 1);
		p = hd->replybuf;
	}
        strcpy(p, newmessage);
	free(newmessage);
}
Esempio n. 20
0
int 
find_side_bndy (
    struct vtx_data **graph,	/* array of vtx data for graph */
    int nvtxs,		/* number of vertices in graph */
    int *assignment,		/* processor each vertex gets assigned to */
    int side,			/* side to take vertices from */
    int new_val,		/* assignment value for boundary vtxs */
    int **pbndy_list		/* returned list, end with zero */
)

{
    int      *edges;		/* loops through edge list */
    int      *bndy_list;	/* returned list, end with zero */
    int       list_length;	/* returned number of vtxs on boundary */
    int       set, set2;	/* set a vertex is in */
    int       i, j;		/* loop counters */

    if (*pbndy_list != NULL) {
	/* Contains list of all vertices on boundary. */
	bndy_list = *pbndy_list;
	i = list_length = 0;
	while (bndy_list[i] != 0) {
	    if (assignment[bndy_list[i]] == side) {
		bndy_list[list_length++] = bndy_list[i];
	    }
	    ++i;
	}
    }

    else {
	bndy_list = smalloc((nvtxs + 1) * sizeof(int));

	list_length = 0;
	for (i = 1; i <= nvtxs; i++) {
	    set = assignment[i];
	    if (set == side) {
		edges = graph[i]->edges;
		for (j = graph[i]->nedges - 1; j; j--) {
		    set2 = assignment[*(++edges)];
		    if (set2 != set) {
			bndy_list[list_length++] = i;
			break;
		    }
		}
	    }
	}
    }

    bndy_list[list_length] = 0;

    for (i = 0; i < list_length; i++) {
	assignment[bndy_list[i]] = (int) new_val;
    }

    /* Shrink out unnecessary space */
    *pbndy_list = srealloc(bndy_list, (list_length + 1) * sizeof(int));

    return (list_length);
}
Esempio n. 21
0
/* debug realloc: srealloc() with memory management */
void *d_realloc( void *oldptr, size_t newsize )
{
	void *p = srealloc( oldptr, newsize );
	
	clog( CL_DEBUG, "srealloc(%p,%d) -> %p", oldptr, newsize, p );
	
	return p;
}
Esempio n. 22
0
static void
setlevel(int level, struct getdb *db, int fd)
{
	if (level >= maxlevel)
		levels = srealloc(levels, (maxlevel=level+16) * sizeof *levels);
	levels[level].l_db = db;
	levels[level].l_fd = fd;
}
Esempio n. 23
0
/* conditioned_on must be an array of integer lists; specifically, the
   ith element must be the list of state numbers on which the ith
   state is conditioned. */
Unspooler *cm_create_unspooler(int nstates_spooled, List **conditioned_on) {
  UnspoolNode *n;
  int i, j;
  Stack *s;
  Unspooler *unsp;
  int *mark;
  int capacity;

  unsp = (Unspooler*)smalloc(sizeof(Unspooler));
  unsp->nstates_spooled = nstates_spooled;
  unsp->nstates_unspooled = 0;
  unsp->spooled_to_unspooled = 
    (UnspoolNode**)smalloc(nstates_spooled * sizeof(UnspoolNode*));
  capacity = nstates_spooled * nstates_spooled;
  unsp->unspooled_to_spooled = (int*)smalloc(capacity * sizeof(int));

  mark = (int*)smalloc(nstates_spooled * sizeof(int));
  s = stk_new_ptr(nstates_spooled);
  for (i = 0; i < nstates_spooled; i++) {
    /* erase marks (used to detect cycles) */
    for (j = 0; j < nstates_spooled; j++) mark[j] = 0;

    unsp->spooled_to_unspooled[i] = cm_new_unspool_node(i);
    stk_push_ptr(s, unsp->spooled_to_unspooled[i]);
    while ((n = (UnspoolNode*)stk_pop_ptr(s)) != NULL) {
      if (conditioned_on[n->oldstate] == NULL ||
          lst_size(conditioned_on[n->oldstate]) == 0) {
        n->newstate = unsp->nstates_unspooled++;

        /* mapping to spooled space */
        if (n->newstate >= capacity) {
          capacity *= 2;
          unsp->unspooled_to_spooled = 
            (int*)srealloc(unsp->unspooled_to_spooled, 
                          capacity * sizeof(int));          
        }
        unsp->unspooled_to_spooled[n->newstate] = i;
      }
      else {
        for (j = 0; j < lst_size(conditioned_on[n->oldstate]); j++) {
          int oldstate = lst_get_int(conditioned_on[n->oldstate], j);
          UnspoolNode *m;

          if (mark[oldstate] == 1)
            die("ERROR: cycle in 'conditioned_on' dependencies.\n");
          mark[oldstate] = 1;

          m = cm_new_unspool_node(oldstate);
          lst_push_ptr(n->children, m);
          stk_push_ptr(s, m);
        }
      }
    }
  }
  stk_free(s);
  sfree(mark);
  return unsp;
}
Esempio n. 24
0
File: req.c Progetto: dolda2000/ashd
void headpreheader(struct hthead *head, const char *name, const char *val)
{
    head->headers = srealloc(head->headers, sizeof(*head->headers) * (head->noheaders + 1));
    memmove(head->headers + 1, head->headers, sizeof(*head->headers) * head->noheaders);
    head->noheaders++;
    head->headers[0] = smalloc(sizeof(*head->headers[0]) * 2);
    head->headers[0][0] = sstrdup(name);
    head->headers[0][1] = sstrdup(val);
}
Esempio n. 25
0
static void
setppi(int f, long j, const char *p)
{
    if (j >= ppisize[f]) {
        ppisize[f] = j + 1;
        ppibuf[f] = srealloc(ppibuf[f], ppisize[f] * sizeof *ppibuf[f]);
    }
    ppibuf[f][j] = p;
}
Esempio n. 26
0
/* Reallocate a category map to allow for the specified size. */
void cm_realloc(CategoryMap *cm, int new_ncats) {
  int i;
  int old_ncats = cm->ncats;
  cm->ncats = new_ncats;
  cm->ranges = srealloc(cm->ranges, (cm->ncats + 1) * sizeof(CategoryRange*));
  cm->conditioned_on = srealloc(cm->conditioned_on,
                                (cm->ncats + 1) * sizeof(List*));
  cm->labelling_precedence = srealloc(cm->labelling_precedence,
                                      (cm->ncats + 1) * sizeof(int));
  cm->fill_precedence = srealloc(cm->fill_precedence,
                                 (cm->ncats + 1) * sizeof(int));
  for (i = old_ncats+1; i <= cm->ncats; i++) {
    cm->ranges[i] = NULL;
    cm->conditioned_on[i] = NULL;
    cm->labelling_precedence[i] = -1;
    cm->fill_precedence[i] = -1;
  }
}
Esempio n. 27
0
void string::append(const char *p, int n)
{
  if (n > 0) {
    int newlen = len + n;
    if (newlen > sz)
      ptr = srealloc(ptr, sz, len, newlen, &sz);
    memcpy(ptr + len, p, n);
    len = newlen;
  }
}
Esempio n. 28
0
File: req.c Progetto: dolda2000/ashd
void headappheader(struct hthead *head, const char *name, const char *val)
{
    int i;

    i = head->noheaders++;
    head->headers = srealloc(head->headers, sizeof(*head->headers) * head->noheaders);
    head->headers[i] = smalloc(sizeof(*head->headers[i]) * 2);
    head->headers[i][0] = sstrdup(name);
    head->headers[i][1] = sstrdup(val);
}
Esempio n. 29
0
static int read_qseq_line(FILE *f, char *fname, char *fields[11]) {
  static const char *spaces = " \t\n";
  static char       *buffer = NULL;
  static size_t      bufsz = 0;
  size_t             s;
  char              *b;
  char              *res;
  int                i;

  if (NULL == buffer) {
    bufsz = 1024;
    buffer = smalloc(bufsz);
  }

  b = buffer;
  s = bufsz;
  b[s - 1] = '*';
  while (NULL != (res = fgets(b, s, f))) {
    if (b[s - 1] == 0 && b[s - 2] != '\n') {
      bufsz *= 2;
      buffer = srealloc(buffer, bufsz);
      b = buffer + s - 1;
      s = bufsz - (b - buffer);
      b[s - 1] = '*';
    } else {
      break;
    }
  }

  if (NULL == res) {
    if (ferror(f)) {
      printf("Error reading %s: %s\n", fname, strerror(errno));
      return -1;
    } else { /* eof */
      return 1;
    }
  }

  /* (*line_no)++; */
  
  b = buffer;
  s = 0;
  for (i = 0; i < 11; i++) {
    fields[i] = buffer + s;
    s += strcspn(buffer + s, spaces);
    if (buffer[s] == '\0') {
      printf("Error reading qseq file: not enough fields found\n");
      return -1;
    }
    buffer[s++] = '\0';
    s += strspn(buffer + s, spaces);
  }

  return 0;
}
Esempio n. 30
0
/* Get administrators of the groups */
static int get_groupadmins(void)
{
	FILE *f;
	int line = 0;
	char buffer[IOBUF_SIZE], *colpos, *grouppos, *endname, *adminpos;

	if (!(f = fopen(adminsfile, "r"))) {
		errstr(_("Cannot open file with group administrators: %s\n"), strerror(errno));
		return -1;
	}
	
	while (fgets(buffer, IOBUF_SIZE, f)) {
		line++;
		if (buffer[0] == ';' || buffer[0] == '#')
			continue;
		/* Skip initial spaces */
		for (colpos = buffer; isspace(*colpos); colpos++);
		if (!*colpos)	/* Empty line? */
			continue;
		/* Find splitting colon */
		for (grouppos = colpos; *colpos && *colpos != ':'; colpos++);
		if (!*colpos || grouppos == colpos) {
			errstr(_("Parse error at line %d. Cannot find end of group name.\n"), line);
			continue;
		}
		/* Cut trailing spaces */
		for (endname = colpos-1; isspace(*endname); endname--);
		*(++endname) = 0;
		/* Skip initial spaces at admins name */
		for (colpos++; isspace(*colpos); colpos++);
		if (!*colpos) {
			errstr(_("Parse error at line %d. Cannot find administrators name.\n"), line);
			continue;
		}
		/* Go through admins name */
		for (adminpos = colpos; !isspace(*colpos); colpos++);
		if (*colpos) {	/* Some characters after name? */
			*colpos = 0;
			/* Skip trailing spaces */
			for (colpos++; isspace(*colpos); colpos++);
			if (*colpos) {
				errstr(_("Parse error at line %d. Trailing characters after administrators name.\n"), line);
				continue;
			}
		}
		if (adminscnt >= adminsalloc)
			adminstable = srealloc(adminstable, sizeof(struct adminstable)*(adminsalloc+=ADMIN_TAB_ALLOC));
		adminstable[adminscnt].grpname = sstrdup(grouppos);
		adminstable[adminscnt++].adminname = sstrdup(adminpos);
	}

	fclose(f);
	qsort(adminstable, adminscnt, sizeof(struct adminstable), admin_cmp);
	return 0;
}