Exemplo n.º 1
0
void
do_prepare (int argc, char *argv[])
{
   size_t name_len;

   name_len = strlen (test_dir);
   name = malloc (name_len + sizeof ("/fcntlXXXXXX"));
   mempcpy (mempcpy (name, test_dir, name_len),
	    "/fcntlXXXXXX", sizeof ("/fcntlXXXXXX"));
  /* Create the temporary file.  */
  fd = mkstemp (name);
  if (fd == -1)
    {
      printf ("cannot open temporary file: %m\n");
      exit (1);
    }
   add_temp_file (name);
}
Exemplo n.º 2
0
static int
writePacket (BrailleDisplay *brl, const unsigned char *packet, size_t size) {
  unsigned char bytes[size];
  unsigned char *byte = bytes;

  byte = mempcpy(byte, packet, size);

  return writeBytes(brl, bytes, byte-bytes);
}
Exemplo n.º 3
0
char *gcov_map_srcfilename(const char *src, const char *gcov_strip,
			const char *gcov_prefix, bool remove_suffix,
			const char *new_suffix)
{
	char *f = (char *) src, *tmp = NULL, *n;
	size_t maxlen;
	unsigned int endpos;
	unsigned int strip_len = gcov_strip ? strlen(gcov_strip) : 0;
	unsigned int prefix_len = gcov_prefix ? strlen(gcov_prefix) : 0;

	assert(new_suffix);

	maxlen = prefix_len + strlen(src) + strlen(new_suffix) + 12;
	tmp = safe_malloc(maxlen);

	endpos = strlen(f);
	if (remove_suffix) {
		while (f[endpos] != '.' && endpos > 0)
			endpos--;

		/* No suffix?  */
		if (endpos == 0)
			goto fail;
	}
	/* IGnore.  */
	if (strip_len >= endpos)
		goto fail;

	if (strncmp(f, gcov_strip, strip_len) == 0) {
		f += strip_len;
	}

	n = tmp;
	if (prefix_len) {
		n = mempcpy(n, gcov_prefix, prefix_len);
	}
	n = mempcpy(n, f, endpos - strip_len);
	n = mempcpy(n, new_suffix, 6);
	return tmp;
fail:
	free(tmp);
	return NULL;
}
Exemplo n.º 4
0
MB_BEGIN_C_DECLS

void * _mb_mempcpy(void *dest, const void *src, size_t n)
{
#if defined(_WIN32) || defined(__ANDROID__)
    return static_cast<char *>(memcpy(dest, src, n)) + n;
#else
    return mempcpy(dest, src, n);
#endif
}
Exemplo n.º 5
0
Arquivo: revert.c Projeto: jjuran/git
static int get_message(const char *raw_message, struct commit_message *out)
{
	const char *encoding;
	const char *abbrev, *subject;
	int abbrev_len, subject_len;
	char *q;

	if (!raw_message)
		return -1;
	encoding = get_encoding(raw_message);
	if (!encoding)
		encoding = "UTF-8";
	if (!git_commit_encoding)
		git_commit_encoding = "UTF-8";

	out->reencoded_message = NULL;
	out->message = raw_message;
	if (strcmp(encoding, git_commit_encoding))
		out->reencoded_message = reencode_string(raw_message,
					git_commit_encoding, encoding);
	if (out->reencoded_message)
		out->message = out->reencoded_message;
	else
		out->message = raw_message;

	abbrev = find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV);
	abbrev_len = strlen(abbrev);

	subject_len = find_commit_subject(out->message, &subject);

	out->parent_label = xmalloc(strlen("parent of ") + abbrev_len +
			      strlen("... ") + subject_len + 1);
	q = out->parent_label;
	q = mempcpy(q, "parent of ", strlen("parent of "));
	out->label = q;
	q = mempcpy(q, abbrev, abbrev_len);
	q = mempcpy(q, "... ", strlen("... "));
	out->subject = q;
	q = mempcpy(q, subject, subject_len);
	*q = '\0';
	return 0;
}
Exemplo n.º 6
0
void *
__mempcpy_chk (void *dst, const void *src, __SIZE_TYPE__ n, __SIZE_TYPE__ size)
{
  /* If size is -1, GCC should always optimize the call into mempcpy.  */
  if (size == (__SIZE_TYPE__) -1)
    abort ();
  ++chk_calls;
  if (n > size)
    __chk_fail ();
  return mempcpy (dst, src, n);
}
Exemplo n.º 7
0
void Private_Impl::convertBGR2RGB ( unsigned char *  in_bgr, unsigned char *  out_rgb, int size ) {
    unsigned char *end = in_bgr + size;
    unsigned char *in_ptr = in_bgr;
    while ( in_ptr < end ) {
        swap ( in_ptr[2], in_ptr[0] );
        in_ptr += 3;
    }
    mempcpy ( out_rgb, in_bgr, size );


}
Exemplo n.º 8
0
char* FAST_FUNC xmalloc_substitute_string(const char *src, int count, const char *sub, const char *repl)
{
	char *buf, *dst, *end;
	size_t sub_len = strlen(sub);
	size_t repl_len = strlen(repl);

	//dbg_msg("subst(s:'%s',count:%d,sub:'%s',repl:'%s'", src, count, sub, repl);

	buf = dst = xmalloc(strlen(src) + count * ((int)repl_len - (int)sub_len) + 1);
	/* we replace each sub with repl */
	while ((end = strstr(src, sub)) != NULL) {
		dst = mempcpy(dst, src, end - src);
		dst = mempcpy(dst, repl, repl_len);
		/*src = end + 1; - GNU findutils 4.5.10 doesn't do this... */
		src = end + sub_len; /* but this. Try "xargs -Iaa echo aaa" */
	}
	strcpy(dst, src);
	//dbg_msg("subst9:'%s'", buf);
	return buf;
}
Exemplo n.º 9
0
void *
stupid_memccpy (void *dst, const void *src, int c, size_t n)
{
  void *p = memchr (src, c, n);

  if (p != NULL)
    return mempcpy (dst, src, p - src + 1);

  memcpy (dst, src, n);
  return NULL;
}
Exemplo n.º 10
0
void
do_prepare (int argc, char *argv[])
{
   char name_len;

#define FNAME FNAME2(TRUNCATE)
#define FNAME2(s) "/" STRINGIFY(s) "XXXXXX"

   name_len = strlen (test_dir);
   name = malloc (name_len + sizeof (FNAME));
   if (name == NULL)
     error (EXIT_FAILURE, errno, "cannot allocate file name");
   mempcpy (mempcpy (name, test_dir, name_len), FNAME, sizeof (FNAME));
   add_temp_file (name);

   /* Open our test file.   */
   fd = mkstemp (name);
   if (fd == -1)
     error (EXIT_FAILURE, errno, "cannot open test file `%s'", name);
}
Exemplo n.º 11
0
Arquivo: Buffer.c Projeto: wrapl/wrapl
static char *extract_chars_rest(buffer_t *Stream) {
	int Length = 0;
	for (node_t *Node = Stream->Head; Node; Node = Node->Next) Length += Node->Length;
	char *Buffer = Riva$Memory$alloc_atomic(Length + 1);
	char *Ptr = Buffer;
	for (node_t *Node = Stream->Head; Node; Node = Node->Next) Ptr = mempcpy(Ptr, Node->Chars, Node->Length);
	Buffer[Length] = 0;
	Stream->Head = Stream->Tail = 0;
	Stream->Position += Length;
	return Buffer;
};
Exemplo n.º 12
0
// copy a chunk of 'state->counter' bytes
static
bool copy_chunk(scanner_state* const state)
{
	const char* const s = state->src;
	const unsigned n = min(state->end - s, state->counter);

	state->dest = mempcpy(state->dest, s, n);
	state->src = s + n;
	state->counter -= n;
	return state->counter == 0;
}
Exemplo n.º 13
0
static long int
__sysconf_check_spec (const char *spec)
{
  int save_errno = errno;

  const char *getconf_dir = __libc_secure_getenv ("GETCONF_DIR") ?: GETCONF_DIR;
  size_t getconf_dirlen = strlen (getconf_dir);
  size_t speclen = strlen (spec);

  char name[getconf_dirlen + sizeof ("/POSIX_V6_") + speclen];
  memcpy (mempcpy (mempcpy (name, getconf_dir, getconf_dirlen),
		   "/POSIX_V6_", sizeof ("/POSIX_V6_") - 1),
	  spec, speclen + 1);

  struct stat64 st;
  long int ret = __xstat64 (_STAT_VER, name, &st) >= 0 ? 1 : -1;

  __set_errno (save_errno);
  return ret;
}
/*HORRIBLE*/
char* ClientMonitorParameter::serialize(){
  char* serial=new char[sizeof(unsigned char)+4*sizeof(float)+4*sizeof(bool)];
  void* next;
  next=mempcpy(serial,&strType,sizeof(unsigned char));
  
  next=mempcpy(next,&dataFlag,sizeof(bool));
  next=mempcpy(next,&migration,sizeof(bool));
  next=mempcpy(next,&recv,sizeof(bool));
  next=mempcpy(next,&send,sizeof(bool));
  
  next=mempcpy(next,&best,sizeof(float));
  next=mempcpy(next,&worst,sizeof(float));
  next=mempcpy(next,&stdev,sizeof(float));
  next=mempcpy(next,&average,sizeof(float));

  return serial;
}
Exemplo n.º 15
0
void
do_prepare (int argc, char *argv[])
{
  size_t name_len;
  struct rlimit64 rlim;

  name_len = strlen (test_dir);
  name = malloc (name_len + sizeof ("/lfsXXXXXX"));
  mempcpy (mempcpy (name, test_dir, name_len),
           "/lfsXXXXXX", sizeof ("/lfsXXXXXX"));
  add_temp_file (name);

  /* Open our test file.   */
  fd = mkstemp64 (name);
  if (fd == -1)
    {
      if (errno == ENOSYS)
	{
	  /* Fail silently.  */
	  error (0, 0, "open64 is not supported");
	  exit (EXIT_SUCCESS);
	}
      else
	error (EXIT_FAILURE, errno, "cannot create temporary file");
    }

  if (getrlimit64 (RLIMIT_FSIZE, &rlim) != 0)
    {
      error (0, errno, "cannot get resource limit");
      exit (0);
    }
  if (rlim.rlim_cur < TWO_GB + 200)
    {
      rlim.rlim_cur = TWO_GB + 200;
      if (setrlimit64 (RLIMIT_FSIZE, &rlim) != 0)
	{
	  error (0, errno, "cannot reset file size limits");
	  exit (0);
	}
    }
}
void StackPush(Stack *s, void *elemAddr){
  
  void *destAddr;
  
  if(s->loglength == s->alloclength){
    s->alloclength *= 2;
    s->data = realloc(s->data,s->alloclength*s->elementsize);
  } 
  destAddr = (char *)s->data + s->loglength*s->elementsize;
  mempcpy((char *)destAddr,(char *)elemAddr,s->elementsize);
  s->loglength += 1;
}
Exemplo n.º 17
0
extern void *nldttp_header_prefix(nldttp_header_t *header, void *data, int *size)
{
	*size = header->size+10;
	void *result = g_malloc0(*size);
	void *pos_next = mempcpy(result,	&header->type_id, 1);
	pos_next = mempcpy(pos_next, &header->priority, 1);
	pos_next = mempcpy(pos_next, &header->packet_num, 2);
	pos_next = mempcpy(pos_next, &header->packet_tot, 2);
	pos_next = mempcpy(pos_next, &header->client_id, 1);
	pos_next = mempcpy(pos_next, &header->client_rec, 1);
	pos_next = mempcpy(pos_next, &header->size, 2);
	pos_next = mempcpy(pos_next, data, header->size);
	return result;
}
Exemplo n.º 18
0
char* mysql_cursor::fetchBlobColumn(unsigned int col_pos)//Do not use this,mysql C API unsupport it now.
{
       int fixed_len = MAX_DATA_BUF_LENGTH;
       char buf[MAX_DATA_BUF_LENGTH];
	memset(buf, 0, sizeof(buf) );
	
	unsigned long fetched_len = 0;
	my_bool       is_null;
       MYSQL_BIND blob_bind;
	memset(&blob_bind,0,sizeof(MYSQL_BIND));
	blob_bind.buffer=buf;
	blob_bind.buffer_length=fixed_len;
	blob_bind.length=&fetched_len;
	blob_bind.buffer_type=MYSQL_TYPE_BLOB;
	blob_bind.is_null=&is_null;
	
	int ret;
	unsigned long offset=0;
	char* final_buf = NULL;
	while((ret=g_mysql.mysql_stmt_fetch_column(stmtp,&blob_bind,col_pos,offset)) == 0)
	{
		offset += fetched_len;
		char* tmp_buf = final_buf;
		final_buf = (char*)malloc(offset);
		if(tmp_buf)
		{
			mempcpy(mempcpy(final_buf,tmp_buf,offset-fetched_len),buf,fetched_len);
			free(tmp_buf);
		}
		else
		{
			memcpy(final_buf,buf,fetched_len);
		}
		
		if(fetched_len < MAX_DATA_BUF_LENGTH)
			break;
	}
	
	return final_buf;
}
Exemplo n.º 19
0
int
sem_unlink (
     const char *name)
{
  char *fname;
  size_t namelen;

  /* Determine where the shmfs is mounted.  */
  INTUSE(__pthread_once) (&__namedsem_once, __where_is_shmfs);

  /* If we don't know the mount points there is nothing we can do.  Ever.  */
  if (mountpoint.dir == NULL)
    {
      __set_errno (ENOSYS);
      return -1;
    }

  /* Construct the filename.  */
  while (name[0] == '/')
    ++name;

  if (name[0] == '\0')
    {
      /* The name "/" is not supported.  */
      __set_errno (ENOENT);
      return -1;
    }
  namelen = strlen (name);

  /* Create the name of the file.  */
  fname = (char *) alloca (mountpoint.dirlen + namelen + 1);
  mempcpy (mempcpy (fname, mountpoint.dir, mountpoint.dirlen),
	     name, namelen + 1);

  /* Now try removing it.  */
  int ret = unlink (fname);
  if (ret < 0 && errno == EPERM)
    __set_errno (EACCES);
  return ret;
}
Exemplo n.º 20
0
static inline void *
translateCells (
  const TranslationTable table,
  unsigned char *target, const unsigned char *source, size_t count
) {
  if (table) {
    while (count--) *target++ = table[*source++];
    return target;
  }

  if (target == source) return target + count;
  return mempcpy(target, source, count);
}
Exemplo n.º 21
0
char *
single_quote(const char *s) {
	char *p;

	startstackstr(&p);

	do {
		char *q;
		size_t len;

		len = strchrnul(s, '\'') - s;

		q = p = makestrspace(len + 3, p);

		*q++ = '\'';
		q = (char *)mempcpy(q, s, len);
		*q++ = '\'';
		s += len;

		stadjust(q - p, &p);

		len = strspn(s, "'");
		if (!len)
			break;

		q = p = makestrspace(len + 3, p);

		*q++ = '"';
		q = (char *)mempcpy(q, s, len);
		*q++ = '"';
		s += len;

		stadjust(q - p, &p);
	} while (*s);

	ustputc(0, &p);

	return stackblock();
}
Exemplo n.º 22
0
char *
single_quote(const char *s) {
	char *p;

	STARTSTACKSTR(p);

	do {
		char *q;
		size_t len;

		len = strchrnul(s, '\'') - s;

		q = p = makestrspace(len + 3, p);

		*q++ = '\'';
		q = mempcpy(q, s, len);
		*q++ = '\'';
		s += len;

		STADJUST(q - p, p);

		len = strspn(s, "'");
		if (!len)
			break;

		q = p = makestrspace(len + 3, p);

		*q++ = '"';
		q = mempcpy(q, s, len);
		*q++ = '"';
		s += len;

		STADJUST(q - p, p);
	} while (*s);

	USTPUTC(0, p);

	return stackblock();
}
Exemplo n.º 23
0
void *__xvr2_util_mempcpy(void *to, const void *from, size_t bytes){
	void *ret_ptr;
#ifdef __USE_GNU
	ret_ptr = mempcpy(to, from, bytes);
#else
#ifdef HAVE_MEMCPY
	ret_ptr = (void *)((char *)memcpy(to, from, bytes) + bytes);
#else
	ret_ptr = (void *)((char *)__xvr2_util_memcpy(to, from, bytes) + bytes);
#endif
#endif
	return ret_ptr;
}
Exemplo n.º 24
0
// concatenate strings
// last va_list arg has to be NULL
// thanks GNU!
char* concat (const char *str, ...)
{
    va_list ap;
    size_t allocated = 100;

    // pointer to concatenated string
    char *result = (char *) malloc (allocated);

    if (result != NULL)
    {
        // working pointers
        char *newp;
        char *wp;
        const char *s;

        va_start (ap, str);

        wp = result;
        for (s = str; s != NULL; s = va_arg (ap, const char *))
        {
            size_t len = strlen (s);

            /* Resize the allocated memory if necessary.  */
            if (wp + len + 1 > result + allocated)
            {
                allocated = (allocated + len) * 2;
                newp = (char *) realloc (result, allocated);
                if (newp == NULL)
                {
                    // oops! realloc didn't work!
                    free (result);
                    va_end(ap);
                    return NULL;
                }
                wp = newp + (wp - result);
                result = newp;
            }

            wp = mempcpy (wp, s, len);
        }

        /* Terminate the result string.  */
        *wp++ = '\0';

        /* Resize memory to the optimal size.  */
        newp = realloc (result, wp - result);
        if (newp != NULL)
            result = newp;

        va_end (ap);
    }
Exemplo n.º 25
0
Arquivo: mbw.c Projeto: bpradipt/mbw
/* asize: number of type 'long' elements in test arrays
 * long_size: sizeof(long) cached
 * type: 0=use memcpy, 1=use dumb copy loop (whatever GCC thinks best)
 *
 * return value: elapsed time in seconds
 */
double worker(unsigned long long asize, long *a, long *b, int type, unsigned long long block_size)
{
    unsigned long long t;
    struct timeval starttime, endtime;
    double te;
    unsigned int long_size=sizeof(long);
    /* array size in bytes */
    unsigned long long array_bytes=asize*long_size;

    if(type==TEST_MEMCPY) { /* memcpy test */
        /* timer starts */
        gettimeofday(&starttime, NULL);
        memcpy(b, a, array_bytes);
        /* timer stops */
        gettimeofday(&endtime, NULL);
    } else if(type==TEST_MCBLOCK) { /* memcpy block test */
        char* aa = (char*)a;
        char* bb = (char*)b;
        gettimeofday(&starttime, NULL);
        for (t=array_bytes; t >= block_size; t-=block_size, aa+=block_size){
            bb=mempcpy(bb, aa, block_size);
        }
        if(t) {
            bb=mempcpy(bb, aa, t);
        }
        gettimeofday(&endtime, NULL);
    } else if(type==TEST_DUMB) { /* dumb test */
        gettimeofday(&starttime, NULL);
        for(t=0; t<asize; t++) {
            b[t]=a[t];
        }
        gettimeofday(&endtime, NULL);
    }

    te=((double)(endtime.tv_sec*1000000-starttime.tv_sec*1000000+endtime.tv_usec-starttime.tv_usec))/1000000;

    return te;
}
Exemplo n.º 26
0
void* memdup_suffix0(const void *p, size_t l) {
        void *ret;

        assert(l == 0 || p);

        /* The same as memdup() but place a safety NUL byte after the allocated memory */

        ret = malloc(l + 1);
        if (!ret)
                return NULL;

        *((uint8_t*) mempcpy(ret, p, l)) = 0;
        return ret;
}
Exemplo n.º 27
0
void
do_prepare (int argc, char *argv[])
{
  size_t name_len;

  name_len = strlen (test_dir);
  name = malloc (name_len + sizeof ("/aioXXXXXX"));
  mempcpy (mempcpy (name, test_dir, name_len),
	   "/aioXXXXXX", sizeof ("/aioXXXXXX"));
  add_temp_file (name);

  /* Open our test file.   */
  fd = mkstemp (name);
  if (fd == -1)
    error (EXIT_FAILURE, errno, "cannot open test file `%s'", name);

  int sz = set_o_direct (fd);
  if (sz != -1)
    {
      blksz = sz;
      printf ("Using O_DIRECT with block size %d\n", blksz);
    }
}
Exemplo n.º 28
0
static int
writePacket (BrailleDisplay *brl, unsigned char type, size_t size, const unsigned char *data) {
  unsigned char bytes[size + 5];
  unsigned char *byte = bytes;

  *byte++ = CE_PKT_BEGIN;
  *byte++ = brl->data->model->identifier;
  *byte++ = size + 1;
  *byte++ = type;
  byte = mempcpy(byte, data, size);
  *byte++ = CE_PKT_END;

  return writeBytes(brl, bytes, byte-bytes);
}
Exemplo n.º 29
0
size_t
strpcpy (char **dest, size_t size, const char *src)
{
  size_t len;

  len = strlen (src);
  if (len >= size)
    {
      if (size > 1)
	*dest = mempcpy (*dest, src, size - 1);
      size = 0;
    }
  else
    {
      if (len > 0)
	{
	  *dest = mempcpy (*dest, src, len);
	  size -= len;
	}
    }
  *dest[0] = '\0';
  return size;
}
Exemplo n.º 30
0
static int compile_regex(struct saved_data *data, spec_t *spec, char **errbuf)
{
    char *reg_buf, *anchored_regex, *cp;
    stem_t *stem_arr = data->stem_arr;
    size_t len;
    int regerr;

    if (spec->regcomp)
        return 0; /* already done */

    data->ncomp++; /* how many compiled regexes required */

    /* Skip the fixed stem. */
    reg_buf = spec->regex_str;
    if (spec->stem_id >= 0)
        reg_buf += stem_arr[spec->stem_id].len;

    /* Anchor the regular expression. */
    len = strlen(reg_buf);
    cp = anchored_regex = malloc(len + 3);
    if (!anchored_regex)
        return -1;
    /* Create ^...$ regexp.  */
    *cp++ = '^';
    cp = mempcpy(cp, reg_buf, len);
    *cp++ = '$';
    *cp = '\0';

    /* Compile the regular expression. */
    regerr = regcomp(&spec->regex, anchored_regex,
                     REG_EXTENDED | REG_NOSUB);
    if (regerr != 0) {
        size_t errsz = 0;
        errsz = regerror(regerr, &spec->regex, NULL, 0);
        if (errsz && errbuf)
            *errbuf = malloc(errsz);
        if (errbuf && *errbuf)
            (void)regerror(regerr, &spec->regex,
                           *errbuf, errsz);

        free(anchored_regex);
        return -1;
    }
    free(anchored_regex);

    /* Done. */
    spec->regcomp = 1;

    return 0;
}