static int pop_raw (lw6sys_context_t * sys_context, lw6sys_hexa_serializer_t * hexa_serializer, u_int8_t * buf, int size) { int ret = 0; int i; int j; char hexa2[3] = { 0, 0, 0 }; // third 0 is *very* important if (check_size (sys_context, hexa_serializer, size * 2)) { for (i = 0; i < size; ++i, hexa_serializer->pos += 2) { j = 0; memcpy (hexa2, hexa_serializer->buf + hexa_serializer->pos, 2); /* * Performing sscanf on long strings is a performance killer * for sscanf calls strlen internally to get the length * of the string... */ sscanf (hexa2, "%02x", &j); buf[i] = (u_int8_t) j; } if (hexa_serializer->pos < hexa_serializer->buf_size && !(hexa_serializer->pos & 0x01)) { ret = 1; } else { lw6sys_log (sys_context, LW6SYS_LOG_WARNING, _x_ ("inconsistent hexa_serializer after pop, pos=%d, buf_size=%d"), hexa_serializer->pos, hexa_serializer->buf_size); } } return ret; }
void check_tab(char **tab) { if (check_char(tab) == 1) put_err("One character is not * or X"); if (check_size(tab) == 1) put_err("The lab is not a rectangle"); }
vector& operator=(const Src& that) { check_size(size(that)); for (int i= 0; i < my_size; ++i) data[i]= that[i]; return *this; }
static int resize (lw6sys_context_t * sys_context, lw6sys_hexa_serializer_t * hexa_serializer, int required) { int ret = 0; int new_size = 0; if (!check_size (sys_context, hexa_serializer, required)) { new_size = (hexa_serializer->buf_size * RESIZE_FACTOR) + RESIZE_PLUS + required; hexa_serializer->buf = LW6SYS_REALLOC (sys_context, hexa_serializer->buf, new_size); if (hexa_serializer->buf) { hexa_serializer->buf_size = new_size; ret = 1; } else { lw6sys_log (sys_context, LW6SYS_LOG_WARNING, _x_ ("can't resize hexa_serializer (new_size=%d), expect serious trouble"), new_size); } } else { // nothing to do... ret = 1; } return ret; }
static int test_mknod(void) { int err = 0; int res; start_test("mknod"); unlink(testfile); res = mknod(testfile, 0644, 0); if (res == -1) { PERROR("mknod"); return -1; } res = check_type(testfile, S_IFREG); if (res == -1) return -1; err += check_mode(testfile, 0644); err += check_nlink(testfile, 1); err += check_size(testfile, 0); res = unlink(testfile); if (res == -1) { PERROR("unlink"); return -1; } res = check_nonexist(testfile); if (res == -1) return -1; if (err) return -1; success(); return 0; }
static int strtab_read(const struct buffer *in, struct parsed_elf *pelf) { Elf64_Ehdr *ehdr; Elf64_Word i; ehdr = &pelf->ehdr; if (ehdr->e_shstrndx >= ehdr->e_shnum) { ERROR("Section header string table index out of range: %d\n", ehdr->e_shstrndx); return -1; } /* For each section of type SHT_STRTAB create a symtab buffer. */ pelf->strtabs = calloc(ehdr->e_shnum, sizeof(struct buffer *)); for (i = 0; i < ehdr->e_shnum; i++) { struct buffer *b; Elf64_Shdr *shdr = &pelf->shdr[i]; if (shdr->sh_type != SHT_STRTAB) continue; b = calloc(1, sizeof(*b)); buffer_splice(b, in, shdr->sh_offset, shdr->sh_size); if (check_size(in, shdr->sh_offset, buffer_size(b), "strtab")) { ERROR("STRTAB section not within bounds: %d\n", i); free(b); return -1; } pelf->strtabs[i] = b; } return 0; }
static int shdr_read(const struct buffer *in, struct parsed_elf *pelf, struct xdr *xdr, int bit64) { struct buffer b; Elf64_Shdr *shdr; Elf64_Ehdr *ehdr; int i; ehdr = &pelf->ehdr; /* cons up an input buffer for the section headers. * Note that the section headers can be anywhere, * per the ELF spec, You'd be surprised how many ELF * readers miss this little detail. */ buffer_splice(&b, in, ehdr->e_shoff, ehdr->e_shentsize * ehdr->e_shnum); if (check_size(in, ehdr->e_shoff, buffer_size(&b), "section headers")) return -1; /* gather up all the shdrs. */ shdr = calloc(ehdr->e_shnum, sizeof(*shdr)); for (i = 0; i < ehdr->e_shnum; i++) { DEBUG("Parsing section %d\n", i); elf_shdr(&b, &shdr[i], ehdr->e_shentsize, xdr, bit64); } pelf->shdr = shdr; return 0; }
static void init_legacy_currval(struct gl_context *ctx) { struct vbo_context *vbo = vbo_context(ctx); struct gl_client_array *arrays = vbo->legacy_currval; GLuint i; memset(arrays, 0, sizeof(*arrays) * VERT_ATTRIB_MAX); /* Set up a constant (StrideB == 0) array for each current * attribute: */ for (i = 0; i < VERT_ATTRIB_MAX; i++) { struct gl_client_array *cl = &arrays[i]; /* Size will have to be determined at runtime: */ cl->Size = check_size(ctx->Current.Attrib[i]); cl->Stride = 0; cl->StrideB = 0; cl->Enabled = 1; cl->Type = GL_FLOAT; cl->Ptr = (const void *)ctx->Current.Attrib[i]; cl->_ElementSize = cl->Size * sizeof(GLfloat); _mesa_reference_buffer_object(ctx, &cl->BufferObj, ctx->Shared->NullBufferObj); } }
/* Convert a number to a certain radix and send over uart. * 32-bit version */ static void norecurse_32(uint32_t input, uint8_t radix) { uint8_t remainder = input % radix; uint8_t *p = charbuff; buffsize = 0; if(input == 0) charbuff[buffsize++] = '0'; while(input >= radix) { if(remainder <= 9) *p++ = remainder + '0'; else *p++ = remainder - 10 + 'A'; buffsize++; input /= radix; remainder = input % radix; } if(remainder > 0) { if(remainder <= 9) *p++ = remainder + '0'; else *p++ = remainder - 10 + 'A'; buffsize++; } // Calculate amount we still need to pad. We never truncate a result. if(fieldwidth > buffsize) fieldwidth -= buffsize; else fieldwidth = 0; while(fieldwidth--) { printf_packet.data[printf_packet.size++] = padchar; check_size(); } while(buffsize > 0) { buffsize--; printf_packet.data[printf_packet.size++] = charbuff[buffsize]; check_size(); } }
vector operator+( const vector& that ) const { check_size(that.my_size); vector sum(my_size); for (unsigned i= 0; i < my_size; ++i) sum[i] = data[i] + that[i]; return sum ; }
SubjectCanvas::SubjectCanvas(UmlCanvas * canvas, int x, int y, int id) : DiagramCanvas(0, canvas, x, y, SUBJECT_CANVAS_MIN_SIZE, SUBJECT_CANVAS_MIN_SIZE, id) { browser_node = canvas->browser_diagram(); itscolor = UmlDefaultColor; check_size(); connect(DrawingSettings::instance(), SIGNAL(changed()), this, SLOT(modified())); }
/* * Implement sequence item sub-script for the type. */ static PyObject *sipVoidPtr_item(PyObject *self, SIP_SSIZE_T idx) { if (check_size(self) < 0 || check_index(self, idx) < 0) return NULL; return SIPBytes_FromStringAndSize( (char *)((sipVoidPtrObject *)self)->voidptr + idx, 1); }
void SubjectCanvas::modified() { // force son reaffichage hide(); check_size(); show(); canvas()->update(); package_modified(); }
static int test_link2(void) { const char *data = testdata; int datalen = testdatalen; int err = 0; int res; start_test("link-unlink-link"); res = create_file(testfile, data, datalen); if (res == -1) return -1; unlink(testfile2); res = link(testfile, testfile2); if (res == -1) { PERROR("link"); return -1; } res = unlink(testfile); if (res == -1) { PERROR("unlink"); return -1; } res = check_nonexist(testfile); if (res == -1) return -1; res = link(testfile2, testfile); if (res == -1) { PERROR("link"); } res = check_type(testfile, S_IFREG); if (res == -1) return -1; err += check_mode(testfile, 0644); err += check_nlink(testfile, 2); err += check_size(testfile, datalen); err += check_data(testfile, data, 0, datalen); res = unlink(testfile2); if (res == -1) { PERROR("unlink"); return -1; } err += check_nlink(testfile, 1); res = unlink(testfile); if (res == -1) { PERROR("unlink"); return -1; } res = check_nonexist(testfile); if (res == -1) return -1; if (err) return -1; success(); return 0; }
void ActivityPartitionCanvas::change_scale() { double scale = the_canvas()->zoom(); Q3CanvasRectangle::setVisible(FALSE); setSize((int) (width_scale100*scale), (int) (height_scale100*scale)); check_size(); recenter(); Q3CanvasRectangle::setVisible(TRUE); }
int main(int argc, char *argv[]) { char out_put[100] = ""; if(argc != 7) { strcat(out_put, "error\n"); printf("%s", out_put); return 0; } else { int i; int j; int64_t p[6]; char* error; for(i = 1; i < 7; i = i + 1) { p[i-1] = strtol(argv[i], &error, 10); if (*error != '\0') { strcat(out_put, "error\n"); printf("%s", out_put); return 0; } } int64_t sides[3]; sides[0] = length(p[0], p[1], p[2], p[3]); sides[1] = length(p[2], p[3], p[4], p[5]); sides[2] = length(p[4], p[5], p[0], p[1]); if(colin_test(p[0], p[1], p[2], p[3], p[4], p[5])) { strcat(out_put, "not a triangle"); printf("%s", out_put); return 0; } for(i = 0; i < 3; i = i + 1) { if(sides[i] == 0) { strcat(out_put, "not a triangle"); printf("%s", out_put); return 0; } } strcat(out_put, check_size(sides)); strcat(out_put, check_angle(sides)); printf("%s\n", out_put); return 0; } }
bool Buffer::write(const void *data, uint32_t len) { if (!check_size(wptr + len)) { memcpy(bptr + wptr, data, len); wptr += len; return true; } error = true; return false; }
void check_all(void) { uint8_t size; for( size =1; size < 255; size++ ) { printf("size=%d\n", size); check_size(size); } }
static noinline int v4l1_compat_get_capabilities( struct video_capability *cap, struct inode *inode, struct file *file, v4l2_kioctl drv) { int err; struct v4l2_framebuffer fbuf; struct v4l2_capability *cap2; cap2 = kzalloc(sizeof(*cap2), GFP_KERNEL); if (!cap2) { err = -ENOMEM; return err; } memset(cap, 0, sizeof(*cap)); memset(&fbuf, 0, sizeof(fbuf)); err = drv(inode, file, VIDIOC_QUERYCAP, cap2); if (err < 0) { dprintk("VIDIOCGCAP / VIDIOC_QUERYCAP: %d\n", err); goto done; } if (cap2->capabilities & V4L2_CAP_VIDEO_OVERLAY) { err = drv(inode, file, VIDIOC_G_FBUF, &fbuf); if (err < 0) { dprintk("VIDIOCGCAP / VIDIOC_G_FBUF: %d\n", err); memset(&fbuf, 0, sizeof(fbuf)); } err = 0; } memcpy(cap->name, cap2->card, min(sizeof(cap->name), sizeof(cap2->card))); cap->name[sizeof(cap->name) - 1] = 0; if (cap2->capabilities & V4L2_CAP_VIDEO_CAPTURE) cap->type |= VID_TYPE_CAPTURE; if (cap2->capabilities & V4L2_CAP_TUNER) cap->type |= VID_TYPE_TUNER; if (cap2->capabilities & V4L2_CAP_VBI_CAPTURE) cap->type |= VID_TYPE_TELETEXT; if (cap2->capabilities & V4L2_CAP_VIDEO_OVERLAY) cap->type |= VID_TYPE_OVERLAY; if (fbuf.capability & V4L2_FBUF_CAP_LIST_CLIPPING) cap->type |= VID_TYPE_CLIPPING; cap->channels = count_inputs(inode, file, drv); check_size(inode, file, drv, &cap->maxwidth, &cap->maxheight); cap->audios = 0; /* FIXME */ cap->minwidth = 48; /* FIXME */ cap->minheight = 32; /* FIXME */ done: kfree(cap2); return err; }
double MedianStats::median() { check_size(1); std::sort(values_.begin(), values_.end()); size_t n {values_.size()}; if (n % 2 == 0) return (values_[n/2 - 1] + values_[n/2])/2.0; else return values_[n/2]; }
std::string unpacker::pop_string() { uint32_t length = pop_uint32(); check_size(length, position_); std::string s = std::string(buffer_ + position_, length); position_ = static_cast<uint32_t>(position_ + length); return s; }
/** * Validate a given file service s. Events are posted according to * its configuration. In case of a fatal event FALSE is returned. */ int check_file(Service_T s) { struct stat stat_buf; ASSERT(s); if (stat(s->path, &stat_buf) != 0) { Event_post(s, Event_Nonexist, STATE_FAILED, s->action_NONEXIST, "file doesn't exist"); return FALSE; } else { s->inf->st_mode = stat_buf.st_mode; if (s->inf->priv.file.st_ino == 0) { s->inf->priv.file.st_ino_prev = stat_buf.st_ino; s->inf->priv.file.readpos = stat_buf.st_size; } else s->inf->priv.file.st_ino_prev = s->inf->priv.file.st_ino; s->inf->priv.file.st_ino = stat_buf.st_ino; s->inf->st_uid = stat_buf.st_uid; s->inf->st_gid = stat_buf.st_gid; s->inf->priv.file.st_size = stat_buf.st_size; s->inf->timestamp = MAX(stat_buf.st_mtime, stat_buf.st_ctime); DEBUG("'%s' file exists check succeeded\n", s->name); Event_post(s, Event_Nonexist, STATE_SUCCEEDED, s->action_NONEXIST, "file exist"); } if (!S_ISREG(s->inf->st_mode)) { Event_post(s, Event_Invalid, STATE_FAILED, s->action_INVALID, "is not a regular file"); return FALSE; } else { DEBUG("'%s' is a regular file\n", s->name); Event_post(s, Event_Invalid, STATE_SUCCEEDED, s->action_INVALID, "is a regular file"); } if (s->checksum) check_checksum(s); if (s->perm) check_perm(s); if (s->uid) check_uid(s); if (s->gid) check_gid(s); if (s->sizelist) check_size(s); if (s->timestamplist) check_timestamp(s); if (s->matchlist) check_match(s); return TRUE; }
void Line::set(char* str_new) { int len = strlen(str_new)+1; check_size(len + 1); memcpy(str, str_new, len + 1); recalc_sz(); }
void sdl_string::set(const char *s, size_t from, size_t len) { if (s == 0) { return; } if (len < 0) return; check_size(from+len); // memcpy will overwrite space[from..from+len-1] if (len>0) ::memcpy(&space[from], s, len); space[from+len] = 0; // maintain invariant that "invisible" terminator is 0 }
int update_status(sqlite3 *db, char *newstatus) { int i; int return_ret=0; int len_ret; int size_ret; int update_ret; int row_ret; len_ret=check_list_len(newstatus); if(len_ret==-1) { return_ret=-1; goto over; } if(len_ret==-2) { return_ret=-2; goto over; } for(i=0;i<MAX_IPC_NUM;i++) { if(newstatus[i]!='c') { size_ret=check_size(newstatus[i]); if(size_ret==-1) { return_ret=-4; goto over; } row_ret=check_row(i); if(row_ret==-1) { return_ret=-5; goto over; } if(row_ret==-2) { return_ret=-3; goto over; } //printf("newstatus[%d]:%c\n",i,newstatus[i]); update_ret=update_status_value(i,newstatus[i]); if(update_ret==-1) { return_ret=-6; goto over; } } } over: return return_ret; }
void ActivityPartitionCanvas::modified() { hide(); hide_lines(); check_size(); show(); update_show_lines(); check_stereotypeproperties(); canvas()->update(); force_sub_inside(FALSE); package_modified(); }
/* Send a NULL terminated string. */ static void send_string(const char *s) { /*while(fieldwidth--) { printf_packet.data[printf_packet.size++] = padchar; check_size(); }*/ while(*s) { printf_packet.data[printf_packet.size++] = *s++; check_size(); } }
int POOL_MEM::strcpy(const char *str) { int len; if (!str) str = ""; len = strlen(str) + 1; check_size(len); memcpy(mem, str, len); return len - 1; }
/* * The buffer implementation for Python v2.6 and later. */ static int sipVoidPtr_getbuffer(PyObject *self, Py_buffer *buf, int flags) { sipVoidPtrObject *v; if (check_size(self) < 0) return -1; v = (sipVoidPtrObject *)self; return PyBuffer_FillInfo(buf, self, v->voidptr, v->size, !v->rw, flags); }
inline osmium::util::MemoryMapping::MemoryMapping(size_t size, mapping_mode mode, int fd, off_t offset) : m_size(check_size(size)), m_offset(offset), m_fd(resize_fd(fd)), m_mapping_mode(mode), m_addr(::mmap(nullptr, m_size, get_protection(), get_flags(), m_fd, m_offset)) { assert(!(fd == -1 && mode == mapping_mode::readonly)); if (!is_valid()) { throw std::system_error(errno, std::system_category(), "mmap failed"); } }