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); }
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); }
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; }
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 }
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; }
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); }
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 ); }
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; }
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; }
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); }
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; };
// 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; }
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; }
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; }
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; }
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; }
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; }
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); }
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(); }
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(); }
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; }
// 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); }
/* 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; }
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; }
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); } }
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); }
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; }
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; }