/* Get information about the file NAME relative to FD in ST. */ int __fxstatat (int vers, int fd, const char *file, struct stat *st, int flag) { int result; if (__builtin_expect (vers == _STAT_VER, 1)) { struct stat16 buf16; result = INLINE_SYSCALL (fstatat, 4, fd, CHECK_STRING (file), __ptrvalue (&buf16), flag); if (result == 0) stat16_to_stat (&buf16, st); } else if (__builtin_expect (vers == _STAT_VER_stat, 1)) { result = INLINE_SYSCALL (fstatat, 4, fd, CHECK_STRING (file), CHECK_1 ((struct stat16 *) st), flag); } else { __set_errno (EINVAL); return -1; } return result; }
int __lchown (const char *file, uid_t owner, gid_t group) { # if __ASSUME_32BITUIDS > 0 return INLINE_SYSCALL (lchown32, 3, CHECK_STRING (file), owner, group); # else # ifdef __NR_lchown32 if (__libc_missing_32bit_uids <= 0) { int result; int saved_errno = errno; result = INLINE_SYSCALL (lchown32, 3, CHECK_STRING (file), owner, group); if (result == 0 || errno != ENOSYS) return result; __set_errno (saved_errno); __libc_missing_32bit_uids = 1; } # endif /* __NR_lchown32 */ if (((owner + 1) > (uid_t) ((__kernel_uid_t) -1U)) || ((group + 1) > (gid_t) ((__kernel_gid_t) -1U))) { __set_errno (EINVAL); return -1; } return INLINE_SYSCALL (lchown, 3, CHECK_STRING (file), owner, group); # endif }
/* test that a server responds correctly to attempted registrations of its name */ static bool nbt_register_own(struct torture_context *tctx) { struct nbt_name_register io; NTSTATUS status; struct nbt_name_socket *nbtsock = nbt_name_socket_init(tctx, NULL); struct socket_address *socket_address; struct nbt_name name; const char *address; const char *myaddress; if (!torture_nbt_get_name(tctx, &name, &address)) return false; myaddress = iface_best_ip(address); socket_address = socket_address_from_strings(tctx, nbtsock->sock->backend_name, myaddress, 0); torture_assert(tctx, socket_address != NULL, "Unable to get address"); status = socket_listen(nbtsock->sock, socket_address, 0, 0); torture_assert_ntstatus_ok(tctx, status, "socket_listen for nbt_register_own failed"); torture_comment(tctx, "Testing name defense to name registration\n"); io.in.name = name; io.in.dest_addr = address; io.in.address = myaddress; io.in.nb_flags = NBT_NODE_B | NBT_NM_ACTIVE; io.in.register_demand = False; io.in.broadcast = True; io.in.multi_homed = False; io.in.ttl = 1234; io.in.timeout = 3; io.in.retries = 0; status = nbt_name_register(nbtsock, tctx, &io); torture_assert_ntstatus_ok(tctx, status, talloc_asprintf(tctx, "Bad response from %s for name register", address)); CHECK_STRING(tctx, io.out.name.name, name.name); CHECK_VALUE(tctx, io.out.name.type, name.type); CHECK_VALUE(tctx, io.out.rcode, NBT_RCODE_ACT); /* check a register demand */ io.in.address = myaddress; io.in.register_demand = True; status = nbt_name_register(nbtsock, tctx, &io); torture_assert_ntstatus_ok(tctx, status, talloc_asprintf(tctx, "Bad response from %s for name register demand", address)); CHECK_STRING(tctx, io.out.name.name, name.name); CHECK_VALUE(tctx, io.out.name.type, name.type); CHECK_VALUE(tctx, io.out.rcode, NBT_RCODE_ACT); return true; }
static int StringEqual(LispObject str1, LispObject str2) { int r; CHECK_STRING(str1); CHECK_STRING(str2); r = StrEqual(LSTRING(str1)->str, LSTRING(str2)->str); return r; }
/* Try to load the cached compiled program binary, verify the device context is * still valid before reuse */ static cl_program x264_opencl_cache_load( x264_t *h, const char *dev_name, const char *dev_vendor, const char *driver_version ) { /* try to load cached program binary */ FILE *fp = x264_fopen( h->param.psz_clbin_file, "rb" ); x264_opencl_function_t *ocl; cl_program program; uint8_t *binary; size_t size; const uint8_t *ptr; cl_int status; if( !fp ) return NULL; ocl = h->opencl.ocl; program = NULL; binary = NULL; fseek( fp, 0, SEEK_END ); size = ftell( fp ); rewind( fp ); CHECKED_MALLOC( binary, size ); if ( fread( binary, 1, size, fp ) != size ) goto fail; ptr = (const uint8_t*)binary; #define CHECK_STRING( STR )\ do {\ size_t len = strlen( STR );\ if( size <= len || strncmp( (char*)ptr, STR, len ) )\ goto fail;\ else {\ size -= (len+1); ptr += (len+1);\ }\ } while( 0 ) CHECK_STRING( dev_name ); CHECK_STRING( dev_vendor ); CHECK_STRING( driver_version ); CHECK_STRING( x264_opencl_source_hash ); #undef CHECK_STRING program = ocl->clCreateProgramWithBinary( h->opencl.context, 1, &h->opencl.device, &size, &ptr, NULL, &status ); if( status != CL_SUCCESS ) program = NULL; fail: fclose( fp ); x264_free( binary ); return program; }
static int anoubisd_msg_eventask_size(const char *buf, int buflen) { struct anoubisd_msg_eventask *msg; struct buf_offset offs[5]; int i, j, total = 0; DECLARE_SIZE(); CAST(msg, buf, buflen); /* Detect offset overlaps */ ADDOFFSET(0, csum); ADDOFFSET(1, path); ADDOFFSET(2, ctxcsum); ADDOFFSET(3, ctxpath); ADDOFFSET(4, ev); for (i=0; i<5; ++i) { int s1, e1; if (offs[i].len == 0) continue; s1 = offs[i].off; e1 = s1 + offs[i].len; if (e1 > total) total = e1; for (j=0; j<i; ++j) { int s2, e2; if (offs[j].len == 0) continue; s2 = offs[j].off; e2 = s2 + offs[j].len; if (s2 < e1 && s1 < e2) return -1; } } SHIFT_FIELD(msg, payload, buf, buflen); if (total > buflen) return -1; ADD_SIZE(total); if (msg->pathlen) CHECK_STRING(buf+msg->pathoff, msg->pathlen); if (msg->ctxpathlen) CHECK_STRING(buf+msg->ctxpathoff, msg->ctxpathlen); if (msg->evlen) { int size = eventdev_hdr_size(buf+msg->evoff, msg->evlen); CHECK_SIZE(size); } RETURN_SIZE(); }
LispObj * Lisp_MakeStringInputStream(LispBuiltin *builtin) /* make-string-input-stream string &optional start end */ { char *string; long start, end, length; LispObj *ostring, *ostart, *oend, *result; oend = ARGUMENT(2); ostart = ARGUMENT(1); ostring = ARGUMENT(0); start = end = 0; CHECK_STRING(ostring); LispCheckSequenceStartEnd(builtin, ostring, ostart, oend, &start, &end, &length); string = THESTR(ostring); if (end - start != length) length = end - start; result = LSTRINGSTREAM(string + start, STREAM_READ, length); return (result); }
/* * Implementation */ LispObj * Lisp_Load(LispBuiltin *builtin) /* load filename &key verbose print if-does-not-exist */ { LispObj *filename, *verbose, *print, *if_does_not_exist; if_does_not_exist = ARGUMENT(3); print = ARGUMENT(2); verbose = ARGUMENT(1); filename = ARGUMENT(0); if (PATHNAMEP(filename)) filename = CAR(filename->data.pathname); else { CHECK_STRING(filename); } return (LispLoadFile(filename, verbose != UNSPEC && verbose != NIL, print != UNSPEC && print != NIL, if_does_not_exist != UNSPEC && if_does_not_exist != NIL)); }
static void check_string_without_embedded_nulls (Lisp_Object object) { CHECK_STRING (object); CHECK_TYPE (memchr (SDATA (object), '\0', SBYTES (object)) == NULL, Qstring_without_embedded_nulls_p, object); }
LispObj * Lisp_PQfnumber(LispBuiltin *builtin) /* pq-fnumber result field-name */ { int number; int field; PGresult *res; LispObj *result, *field_name; field_name = ARGUMENT(1); result = ARGUMENT(0); if (!CHECKO(result, PGresult_t)) LispDestroy("%s: cannot convert %s to PGresult*", STRFUN(builtin), STROBJ(result)); res = (PGresult*)(result->data.opaque.data); CHECK_STRING(field_name); number = PQfnumber(res, THESTR(field_name)); return (INTEGER(number)); }
static bool module_copy_string_contents (emacs_env *env, emacs_value value, char *buffer, ptrdiff_t *length) { MODULE_FUNCTION_BEGIN (false); Lisp_Object lisp_str = value_to_lisp (value); CHECK_STRING (lisp_str); Lisp_Object lisp_str_utf8 = ENCODE_UTF_8 (lisp_str); ptrdiff_t raw_size = SBYTES (lisp_str_utf8); ptrdiff_t required_buf_size = raw_size + 1; eassert (length != NULL); if (buffer == NULL) { *length = required_buf_size; return true; } eassert (*length >= 0); if (*length < required_buf_size) { *length = required_buf_size; xsignal0 (Qargs_out_of_range); } *length = required_buf_size; memcpy (buffer, SDATA (lisp_str_utf8), raw_size + 1); return true; }
LispObj * Lisp_XawTextSearch(LispBuiltin *builtin) /* xaw-text-search widget direction text */ { Widget widget; XawTextScanDirection direction; XawTextBlock block; LispObj *owidget, *odirection, *otext; otext = ARGUMENT(2); odirection = ARGUMENT(1); owidget = ARGUMENT(0); if (!CHECKO(owidget, xawWidget_t)) LispDestroy("%s: cannot convert %s to Widget", STRFUN(builtin), STROBJ(owidget)); widget = (Widget)(owidget->data.opaque.data); CHECK_INDEX(odirection); direction = (XawTextPosition)FIXNUM_VALUE(odirection); if (direction != XawsdLeft && direction != XawsdRight) LispDestroy("%s: %d does not fit in XawTextScanDirection", STRFUN(builtin), direction); CHECK_STRING(otext); block.firstPos = 0; block.ptr = THESTR(otext); block.length = strlen(block.ptr); block.format = FMT8BIT; return (FIXNUM(XawTextSearch(widget, direction, &block))); }
/* helper function for setf * DONT explicitly call. Non standard function */ LispObj * Lisp_XeditCharStore(LispBuiltin *builtin) /* xedit::char-store string index value */ { int character; long offset, length; LispObj *ostring, *oindex, *ovalue; ovalue = ARGUMENT(2); oindex = ARGUMENT(1); ostring = ARGUMENT(0); CHECK_STRING(ostring); CHECK_INDEX(oindex); length = STRLEN(ostring); offset = FIXNUM_VALUE(oindex); if (offset >= length) LispDestroy("%s: index %ld too large for string length %ld", STRFUN(builtin), offset, length); CHECK_SCHAR(ovalue); CHECK_STRING_WRITABLE(ostring); character = SCHAR_VALUE(ovalue); if (character < 0 || character > 255) LispDestroy("%s: cannot represent character %d", STRFUN(builtin), character); THESTR(ostring)[offset] = character; return (ovalue); }
LispObj * Lisp_Char(LispBuiltin *builtin) /* char string index schar simple-string index */ { unsigned char *string; long offset, length; LispObj *ostring, *oindex; oindex = ARGUMENT(1); ostring = ARGUMENT(0); CHECK_STRING(ostring); CHECK_INDEX(oindex); offset = FIXNUM_VALUE(oindex); string = (unsigned char*)THESTR(ostring); length = STRLEN(ostring); if (offset >= length) LispDestroy("%s: index %ld too large for string length %ld", STRFUN(builtin), offset, length); return (SCHAR(string[offset])); }
/* Get information about the file NAME in BUF. */ int __lxstat (int vers, const char *name, struct stat *buf) { #if __ASSUME_STAT64_SYSCALL == 0 struct kernel_stat kbuf; #endif int result; if (vers == _STAT_VER_KERNEL) return INLINE_SYSCALL (lstat, 2, CHECK_STRING (name), CHECK_1 ((struct kernel_stat *) buf)); #if __ASSUME_STAT64_SYSCALL > 0 { struct stat64 buf64; result = INLINE_SYSCALL (lstat64, 2, CHECK_STRING (name), __ptrvalue (&buf64)); if (result == 0) result = __xstat32_conv (vers, &buf64, buf); return result; } #else # if defined __NR_stat64 /* To support 32 bit UIDs, we have to use stat64. The normal stat call only returns 16 bit UIDs. */ if (! __have_no_stat64) { struct stat64 buf64; result = INLINE_SYSCALL (lstat64, 2, CHECK_STRING (name), __ptrvalue (&buf64)); if (result == 0) result = __xstat32_conv (vers, &buf64, buf); if (result != -1 || errno != ENOSYS) return result; __have_no_stat64 = 1; } # endif result = INLINE_SYSCALL (lstat, 2, CHECK_STRING (name), __ptrvalue (&kbuf)); if (result == 0) result = __xstat_conv (vers, &kbuf, buf); return result; #endif }
/* Compile a regexp and signal a Lisp error if anything goes wrong. */ void compile_pattern (Lisp_Object pattern, struct re_pattern_buffer *bufp, char *translate, int backward) { char *val; Lisp_Object dummy; if (EQ (pattern, last_regexp) && translate == bufp->translate /* 92.4.10 by K.Handa */ /* 93.7.13 by K.Handa */ && NILP (current_buffer->mc_flag) == !bufp->mc_flag && (!bufp->syntax_version || bufp->syntax_version == syntax_table_version) && (!bufp->category_version || bufp->category_version == category_table_version)) return; if (CONSP (pattern)) /* pre-compiled regexp */ { Lisp_Object compiled; val = 0; pattern = XCONS (pattern)->car; if (CONSP (pattern) && (compiled = backward ? XCONS(pattern)->cdr : XCONS(pattern)->car) && XTYPE (compiled) == Lisp_Vector && XVECTOR (compiled)->size == 4) { /* set_pattern will set bufp->allocated to NULL */ set_pattern (compiled, bufp, translate); return; } val = "Invalied pre-compiled regexp"; goto invalid_regexp; } CHECK_STRING (pattern, 0); last_regexp = Qnil; bufp->translate = translate; bufp->syntax_version = bufp->category_version = 0; /* 93.7.13 by K.Handa */ /* 92.7.10 by T.Enami 'bufp->allocated == 0' means bufp->buffer points to pre-compiled pattern in a lisp string, which should not be 'realloc'ed. */ if (bufp->allocated == 0) bufp->buffer = 0; val = re_compile_pattern (XSTRING (pattern)->data, XSTRING (pattern)->size, bufp); if (val) { invalid_regexp: dummy = build_string (val); while (1) Fsignal (Qinvalid_regexp, Fcons (dummy, Qnil)); } last_regexp = pattern; return; }
System::String^ NAMESPACE_OSGEO_FDO_COMMANDS_SQL::ISQLCommandImp::SQLStatement::get() { FdoString* result; EXCEPTION_HANDLER(result = GetImpObj()->GetSQLStatement()) return CHECK_STRING(result); }
System::String^ NAMESPACE_OSGEO_FDO_COMMANDS_LOCKING::ILockedObjectReaderImp::GetLongTransaction() { FdoString* result; EXCEPTION_HANDLER(result = GetImpObj()->GetLongTransaction()) return CHECK_STRING(result); }
System::String^ NAMESPACE_OSGEO_FDO_XML::XmlFeatureFlags::GmlIdPrefix::get() { FdoString* result; EXCEPTION_HANDLER(result = GetImpObj()->GetGmlIdPrefix()) return CHECK_STRING(result); }
System::String^ NAMESPACE_OSGEO_FDO_XML::XmlFeatureFlags::CollectionName::get() { FdoString* result; EXCEPTION_HANDLER(result = GetImpObj()->GetCollectionName()) return CHECK_STRING(result); }
System::String^ NAMESPACE_OSGEO_FDO_PROVIDERS_RDBMS_OVERRIDE_ODBC::OvPhysicalSchemaMapping::Provider::get() { FdoString* unobj; EXCEPTION_HANDLER(unobj = GetImpObj()->GetProvider()) return CHECK_STRING(unobj); }
System::String^ NAMESPACE_OSGEO_FDO_PROVIDERS_RDBMS_OVERRIDE_MYSQL::OvClassDefinition::AutoIncrementPropertyName::get() { FdoString * result; EXCEPTION_HANDLER(result = GetImpObj()->GetAutoIncrementPropertyName()) return CHECK_STRING(result); }
System::String^ NAMESPACE_OSGEO_FDO_PROVIDERS_RDBMS::ISpatialIndexReaderImp::SpatialContextName::get() { FdoString* unobj; EXCEPTION_HANDLER(unobj = GetImpObj()->GetSpatialContextName()) return CHECK_STRING(unobj); }
System::String^ NAMESPACE_OSGEO_FDO_COMMANDS_SPATIALCONTEXT::IActivateSpatialContextImp::Name::get() { FdoString* result; EXCEPTION_HANDLER(result = GetImpObj()->GetName()) return CHECK_STRING(result); }
/* Get information about the file FD in BUF. */ int __lxstat (int vers, const char *name, struct stat *buf) { if (vers == _STAT_VER_KERNEL || vers == _STAT_VER_LINUX) return INLINE_SYSCALL (lstat, 2, CHECK_STRING (name), CHECK_1 (buf)); __set_errno (EINVAL); return -1; }
/* Truncate the file referenced by FD to LENGTH bytes. */ int truncate64 (const char *path, off64_t length) { unsigned int low = length & 0xffffffff; unsigned int high = length >> 32; int result = INLINE_SYSCALL (truncate64, 3, CHECK_STRING (path), __LONG_LONG_PAIR (high, low)); return result; }
std::wstring _daijoubu_node::node_as_string( __in const _daijoubu_node &node, __in_opt bool verbose ) { uint8_t flag = 0; std::wstringstream result; if(verbose) { result << L"(" << VALUE_AS_HEX(daijoubu_uid, node.m_uid) << L") "; } result << CHECK_STRING(daijoubu::acquire()->acquire_token_factory()->at( node.m_token).to_string(verbose)) << L" [" << node.m_children.size() << L"]"; if(node.m_children.empty()) { flag |= DAIJOUBU_LEAF_NODE; } if(node.m_parent == INVALID_NODE_PARENT) { flag |= DAIJOUBU_ROOT_NODE; } if(verbose && flag) { result << L" ("; if(flag & DAIJOUBU_ROOT_NODE) { result << L"ROOT"; if(flag & DAIJOUBU_LEAF_NODE) { result << L", LEAF"; } } else if(flag & DAIJOUBU_LEAF_NODE) { result << L"LEAF"; } result << L")"; } return CHECK_STRING(result.str()); }
int __xstat (int vers, const char *file, struct stat *buf) { if (__builtin_expect (vers == _STAT_VER, 1)) { struct stat16 buf16; int result = __syscall_stat (CHECK_STRING (file), __ptrvalue (&buf16)); if (result == 0) stat16_to_stat (&buf16, buf); return result; } else if (__builtin_expect (vers == _STAT_VER_stat, 1)) return __syscall_stat (CHECK_STRING (file), CHECK_1 ((struct stat16 *) buf)); else { __set_errno (EINVAL); return -1; } }
/* Create a device file named PATH, with permission and special bits MODE and device number DEV (which can be constructed from major and minor device numbers with the `makedev' macro above). */ int __xmknod (int vers, const char *path, mode_t mode, dev_t *dev) { if (vers != _MKNOD_VER) { __set_errno (EINVAL); return -1; } return INLINE_SYSCALL (mknod, 3, CHECK_STRING (path), mode, *dev); }
int __real_chown (const char *file, uid_t owner, gid_t group) { static int __libc_old_chown; int result; if (!__libc_old_chown) { int saved_errno = errno; #ifdef __NR_chown32 if (__libc_missing_32bit_uids <= 0) { int result; int saved_errno = errno; result = INLINE_SYSCALL (chown32, 3, CHECK_STRING (file), owner, group); if (result == 0 || errno != ENOSYS) return result; __set_errno (saved_errno); __libc_missing_32bit_uids = 1; } #endif /* __NR_chown32 */ if (((owner + 1) > (uid_t) ((__kernel_uid_t) -1U)) || ((group + 1) > (gid_t) ((__kernel_gid_t) -1U))) { __set_errno (EINVAL); return -1; } result = INLINE_SYSCALL (chown, 3, CHECK_STRING (file), owner, group); if (result >= 0 || errno != ENOSYS) return result; __set_errno (saved_errno); __libc_old_chown = 1; } return __lchown (file, owner, group); }