static struct client_socket *client_socket_create( struct addrinfo *addrinfos, void (*fai)(struct addrinfo *)) { struct connector *c = xalloc(sizeof *c); struct client_socket *s = xalloc(sizeof *s); c->socket = s; tasklet_init(&c->tasklet, &s->base.mutex, c); wait_list_init(&c->connecting, 0); c->fd = -1; c->connected = 0; c->next_addrinfo = c->addrinfos = addrinfos; c->fai = fai; error_init(&c->err); simple_socket_init(&s->base, &client_socket_ops, -1); s->connector = c; /* Start connecting */ mutex_lock(&s->base.mutex); start_connecting(c); tasklet_later(&c->tasklet, finish_connecting); mutex_unlock(&s->base.mutex); return s; }
atf_error_t atf_error_new(const char *type, void *data, size_t datalen, void (*format)(const atf_error_t, char *, size_t)) { atf_error_t err; PRE(!error_on_flight); PRE(data != NULL || datalen == 0); PRE(datalen != 0 || data == NULL); err = malloc(sizeof(*err)); if (err == NULL) err = atf_no_memory_error(); else { if (!error_init(err, type, data, datalen, format)) { free(err); err = atf_no_memory_error(); } else { err->m_free = true; error_on_flight = true; } } INV(err != NULL); POST(error_on_flight); return err; }
static struct server_socket *bound_server_socket(struct socket_factory *gf, const char *host, const char *service, struct error *err_out) { struct addrinfo *ai, *addrinfos, hints; int n_addrs = 0, n_sockets = 0; int *fds; int res; struct simple_server_socket *s; struct error err; assert(gf->ops == &simple_socket_factory_ops); /* See RFC4038, section 6.3.1. */ memset(&hints, 0, sizeof hints); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; hints.ai_flags = AI_PASSIVE; res = getaddrinfo(host, service, &hints, &addrinfos); if (res) { error_set(err_out, ERROR_OS, "resolving network address: %s", gai_strerror(res)); return NULL; } /* Should have at least one addrinfo */ assert(addrinfos); /* Count how many addresses we have */ for (ai = addrinfos; ai; ai = ai->ai_next) n_addrs++; /* Allocate space for the fds */ fds = xalloc(n_addrs * sizeof *fds); /* Create sockets */ error_init(&err); for (ai = addrinfos; ai; ai = ai->ai_next) { int fd = make_bound_socket(ai, &err); if (fd >= 0) fds[n_sockets++] = fd; } freeaddrinfo(addrinfos); /* If no sockets were successfully bound, report an error. */ if (n_sockets == 0) { error_propogate(&err, err_out); free(fds); return NULL; } s = simple_server_socket_create(fds, n_sockets); error_fini(&err); free(fds); return &s->base; }
static MonoArray* create_names_array_idx_dynamic (const guint16 *names, int ml, MonoError *error) { MonoArray *ret; MonoDomain *domain; int i, len = 0; error_init (error); if (names == NULL) return NULL; domain = mono_domain_get (); for (i = 0; i < ml; i++) { if (names [i] == 0) break; len++; } ret = mono_array_new_cached (mono_domain_get (), mono_get_string_class (), len, error); return_val_if_nok (error, NULL); for(i = 0; i < len; i++) mono_array_setref (ret, i, mono_string_new (domain, pattern2string (names [i]))); return ret; }
gpointer ves_icall_System_Threading_Mutex_CreateMutex_internal (MonoBoolean owned, MonoStringHandle name, MonoBoolean *created, MonoError *error) { gpointer mutex; error_init (error); *created = TRUE; /* Need to blow away any old errors here, because code tests * for ERROR_ALREADY_EXISTS on success (!) to see if a mutex * was freshly created */ mono_w32error_set_last (ERROR_SUCCESS); if (MONO_HANDLE_IS_NULL (name)) { mutex = mutex_create (owned); } else { gchar *utf8_name = mono_string_handle_to_utf8 (name, error); return_val_if_nok (error, NULL); mutex = namedmutex_create (owned, utf8_name); if (mono_w32error_get_last () == ERROR_ALREADY_EXISTS) *created = FALSE; g_free (utf8_name); } return mutex; }
static MonoBoolean construct_culture (MonoCultureInfo *this_obj, const CultureInfoEntry *ci, MonoError *error) { MonoDomain *domain = mono_domain_get (); error_init (error); this_obj->lcid = ci->lcid; MONO_OBJECT_SETREF (this_obj, name, mono_string_new (domain, idx2string (ci->name))); MONO_OBJECT_SETREF (this_obj, englishname, mono_string_new (domain, idx2string (ci->englishname))); MONO_OBJECT_SETREF (this_obj, nativename, mono_string_new (domain, idx2string (ci->nativename))); MONO_OBJECT_SETREF (this_obj, win3lang, mono_string_new (domain, idx2string (ci->win3lang))); MONO_OBJECT_SETREF (this_obj, iso3lang, mono_string_new (domain, idx2string (ci->iso3lang))); MONO_OBJECT_SETREF (this_obj, iso2lang, mono_string_new (domain, idx2string (ci->iso2lang))); // It's null for neutral cultures if (ci->territory > 0) MONO_OBJECT_SETREF (this_obj, territory, mono_string_new (domain, idx2string (ci->territory))); MonoArray *native_calendar_names = create_names_array_idx (ci->native_calendar_names, NUM_CALENDARS, error); return_val_if_nok (error, FALSE); MONO_OBJECT_SETREF (this_obj, native_calendar_names, native_calendar_names); this_obj->parent_lcid = ci->parent_lcid; this_obj->datetime_index = ci->datetime_format_index; this_obj->number_index = ci->number_format_index; this_obj->calendar_type = ci->calendar_type; this_obj->text_info_data = &ci->text_info; return TRUE; }
int watchdog_init(watchdog_t *w, int inactivity_timeout, error_t *err) { pthread_t thread_id; int error_code; daemon_assert(w != NULL); daemon_assert(inactivity_timeout > 0); daemon_assert(err != NULL); pthread_mutex_init(&w->mutex, NULL); w->inactivity_timeout = inactivity_timeout; w->oldest = NULL; w->newest = NULL; error_code = pthread_create(&thread_id, NULL, watcher, w); if (error_code != 0) { error_init(err, error_code, "error %d from pthread_create()", error_code); return 0; } pthread_detach(thread_id); daemon_assert(invariant(w)); return 1; }
gboolean mono_rand_try_get_bytes (gpointer *handle, guchar *buffer, gint buffer_size, MonoError *error) { gint count = 0; error_init (error); do { if (buffer_size - count >= sizeof (gint32) && RAND_MAX >= 0xFFFFFFFF) { *(gint32*) buffer = rand(); count += sizeof (gint32); buffer += sizeof (gint32) / sizeof (guchar); } else if (buffer_size - count >= sizeof (gint16) && RAND_MAX >= 0xFFFF) { *(gint16*) buffer = rand(); count += sizeof (gint16); buffer += sizeof (gint16) / sizeof (guchar); } else if (buffer_size - count >= sizeof (gint8) && RAND_MAX >= 0xFF) { *(gint8*) buffer = rand(); count += sizeof (gint8); buffer += sizeof (gint8) / sizeof (guchar); } } while (count < buffer_size); return TRUE; }
static void receiver_init(struct receiver *r, struct async_transport *t) { mutex_init(&r->mutex); error_init(&r->err); r->received = 0; r->server = async_transport_serve(t, handler, r, &r->err); if (!r->server) die("%s", error_message(&r->err)); }
PyMODINIT_FUNC initheimdal(void) { PyObject *module, *self; module = Py_InitModule("heimdal", module_methods); self = PyModule_GetDict(module); error_init(self); }
gpointer ves_icall_System_Threading_Mutex_OpenMutex_internal (MonoStringHandle name, gint32 rights G_GNUC_UNUSED, gint32 *err, MonoError *error) { error_init (error); gchar *utf8_name = mono_string_handle_to_utf8 (name, error); return_val_if_nok (error, NULL); gpointer handle = mono_w32mutex_open (utf8_name, rights, err); g_free (utf8_name); return handle; }
void ftdi_device_init(ftdi_device_t* dev, struct ftdi_context* libftdi_context, struct usb_bus* libusb_bus, struct usb_device* libusb_device) { dev->libftdi_context = libftdi_context; dev->libusb_device = libusb_device; dev->bus = libusb_bus->location; string_scanf(libusb_device->filename, "%d", &dev->address); dev->product_id = libusb_device->descriptor.idProduct; switch (libusb_device->descriptor.bcdDevice) { case 0x0400: dev->chip = ftdi_chip_bm; break; case 0x0200: if (!libusb_device->descriptor.iSerialNumber) dev->chip = ftdi_chip_bm; else dev->chip = ftdi_chip_am; break; case 0x0500: dev->chip = ftdi_chip_2232c; break; case 0x0600: dev->chip = ftdi_chip_r; break; case 0x0700: dev->chip = ftdi_chip_2232h; break; case 0x0800: dev->chip = ftdi_chip_4232h; break; case 0x0900: dev->chip = ftdi_chip_232h; break; default: dev->chip = ftdi_chip_unkown; } dev->interface = ftdi_interface_any; dev->baud_rate = 0; dev->data_bits = 0; dev->stop_bits = 0; dev->parity= ftdi_parity_none; dev->flow_ctrl = ftdi_flow_ctrl_off; dev->break_type = ftdi_break_off; dev->timeout = 0.0; dev->latency = 0.0; dev->num_read = 0; dev->num_written = 0; error_init(&dev->error, ftdi_errors); }
atf_error_t atf_no_memory_error(void) { PRE(!error_on_flight); error_init(&no_memory_error, "no_memory", NULL, 0, no_memory_format); error_on_flight = true; return &no_memory_error; }
static json_t *parse_json(lex_t *lex, json_error_t *error) { error_init(error); lex_scan(lex, error); if(lex->token != '[' && lex->token != '{') { error_set(error, lex, "'[' or '{' expected"); return NULL; } return parse_value(lex, error); }
/* * Returns TRUE if there is "something" where the Authenticode signature is * normally located. Returns FALSE is data directory is empty. * * Note: Neither the structure nor the signature is verified by this function. */ MonoBoolean ves_icall_System_Security_Policy_Evidence_IsAuthenticodePresent (MonoReflectionAssemblyHandle refass, MonoError *error) { error_init (error); if (MONO_HANDLE_IS_NULL (refass)) return FALSE; MonoAssembly *assembly = MONO_HANDLE_GETVAL (refass, assembly); if (assembly && assembly->image) { return (MonoBoolean)mono_image_has_authenticode_entry (assembly->image); } return FALSE; }
void system_init(void) { error_init(); sms_init(); pio_init(); vdp_init(); render_init(); sound_init(); sms.save = 0; }
int main(int argc, char *argv[]) { mem_init(); #ifdef __linux__ #if DXX_WORDS_NEED_ALIGNMENT prctl(PR_SET_UNALIGN, PR_UNALIGN_NOPRINT, 0, 0, 0); #endif #else error_init(msgbox_error); set_warn_func(msgbox_warning); #endif return dsx::main(argc, argv); }
static void handler(struct stream *input, void *v_r) { struct incoming *i = xalloc(sizeof *i); i->receiver = v_r; i->input = input; mutex_init(&i->mutex); tasklet_init(&i->tasklet, &i->mutex, i); growbuf_init(&i->buf, 10); error_init(&i->err); tasklet_later(&i->tasklet, read_message); }
guint32 mono_dynstream_insert_mstring (MonoDynamicStream *sh, MonoString *str, MonoError *error) { MONO_REQ_GC_UNSAFE_MODE; error_init (error); char *name = mono_string_to_utf8_checked_internal (str, error); return_val_if_nok (error, -1); guint32 idx; idx = mono_dynstream_insert_string (sh, name); g_free (name); return idx; }
/************************************************************************************************** CONF_SET_LOGGING Sets the logging type and opens the syslog connection if necessary. **************************************************************************************************/ void conf_set_logging(void) { char *logtype; /* logtype is preset to LOG_DAEMON unless overridden */ logtype = STRDUP(conf_get(&Conf, "log", NULL)); strtolower(logtype); if (err_file) { if (err_file != stderr && err_file != stdout) fclose(err_file); err_file = NULL; } else { closelog(); } if (!strcasecmp(logtype, "stderr")) { err_file = stderr; closelog(); } else if (!strcasecmp(logtype, "stdout")) { err_file = stdout; closelog(); } else if (!strcasecmp(logtype, "log_daemon")) error_init(NULL, LOG_DAEMON); else if (!strcasecmp(logtype, "log_local0")) error_init(NULL, LOG_LOCAL0); else if (!strcasecmp(logtype, "log_local1")) error_init(NULL, LOG_LOCAL1); else if (!strcasecmp(logtype, "log_local2")) error_init(NULL, LOG_LOCAL2); else if (!strcasecmp(logtype, "log_local3")) error_init(NULL, LOG_LOCAL3); else if (!strcasecmp(logtype, "log_local4")) error_init(NULL, LOG_LOCAL4); else if (!strcasecmp(logtype, "log_local5")) error_init(NULL, LOG_LOCAL5); else if (!strcasecmp(logtype, "log_local6")) error_init(NULL, LOG_LOCAL6); else if (!strcasecmp(logtype, "log_local7")) error_init(NULL, LOG_LOCAL7); else { FILE *fp; if (!(fp = fopen(logtype, "a"))) Warn("%s: %s: %s", opt_conf, logtype, _("Error opening log file")); err_file = fp; closelog(); } RELEASE(logtype); }
/** * mono_exception_from_name_two_strings_checked: * \param image the Mono image where to look for the class * \param name_space the namespace for the class * \param name class name * \param a1 first string argument to pass * \param a2 second string argument to pass * \param error set on error * * Creates an exception from a constructor that takes two string * arguments. * * \returns the initialized exception instance. On failure returns * NULL and sets \p error. */ MonoExceptionHandle mono_exception_from_name_two_strings_checked (MonoImage *image, const char *name_space, const char *name, MonoStringHandle a1, MonoStringHandle a2, MonoError *error) { HANDLE_FUNCTION_ENTER (); MonoClass *klass; error_init (error); klass = mono_class_load_from_name (image, name_space, name); HANDLE_FUNCTION_RETURN_REF (MonoException, create_exception_two_strings (klass, a1, a2, error)); }
int ftdi_context_init(ftdi_context_t* context) { if (context != ftdi_default_context) { context->num_devices = 0; context->devices = 0; context->num_references = 1; } else context->num_references++; error_init(&context->error, ftdi_errors); return ftdi_context_refresh(context); }
gpointer ves_icall_System_Security_Principal_WindowsIdentity_GetUserToken (MonoStringHandle username, MonoError *error) { gpointer token = (gpointer)-2; error_init (error); #if defined (HAVE_PWD_H) && !defined (HOST_WASM) #ifdef HAVE_GETPWNAM_R struct passwd pwd; size_t fbufsize; gchar *fbuf; gint32 retval; #endif struct passwd *p; gchar *utf8_name; gboolean result; utf8_name = mono_string_handle_to_utf8 (username, error); return_val_if_nok (error, NULL); #ifdef HAVE_GETPWNAM_R #ifdef _SC_GETPW_R_SIZE_MAX fbufsize = mono_sysconf (_SC_GETPW_R_SIZE_MAX); #else fbufsize = MONO_SYSCONF_DEFAULT_SIZE; #endif fbuf = (gchar *)g_malloc0 (fbufsize); retval = getpwnam_r (utf8_name, &pwd, fbuf, fbufsize, &p); result = ((retval == 0) && (p == &pwd)); #else /* default to non thread-safe but posix compliant function */ p = getpwnam (utf8_name); result = (p != NULL); #endif if (result) { token = GINT_TO_POINTER (p->pw_uid); } #ifdef HAVE_GETPWNAM_R g_free (fbuf); #endif g_free (utf8_name); #endif /* HAVE_PWD_H */ return token; }
void do_repurldef(char* val) { url_t* u=NULL; u=parse_url(val); /* FIXME Check the URL if you add support for databases that cannot be * both input and output urls */ if(u==NULL||u->type==url_unknown||u->type==url_stdin){ error(0,_("Unsupported output URL-type:%s\n"),val); } else { error_init(u,0); } }
void mudlle_init(void) { garbage_init(); global_init(); strbuf_init(); print_init(); stack_init(); module_init(); runtime_init(); compile_init(); mcompile_init(); interpret_init(); error_init(); ports_init(); context_init(); }
/** * mono_exception_from_token_two_strings_checked: * * Same as mono_exception_from_name_two_strings, but lookup the exception class using * IMAGE and TOKEN. */ MonoExceptionHandle mono_exception_from_token_two_strings_checked (MonoImage *image, guint32 token, MonoStringHandle a1, MonoStringHandle a2, MonoError *error) { HANDLE_FUNCTION_ENTER (); MonoClass *klass; error_init (error); klass = mono_class_get_checked (image, token, error); mono_error_assert_ok (error); /* FIXME handle the error. */ HANDLE_FUNCTION_RETURN_REF (MonoException, create_exception_two_strings (klass, a1, a2, error)); }
static void sender_init(struct sender *s, struct async_transport *t, struct address *addr) { s->transport = t; s->address = addr; mutex_init(&s->mutex); tasklet_init(&s->tasklet, &s->mutex, s); error_init(&s->err); s->output = NULL; s->buf = c_string_bytes("Hello"); mutex_lock(&s->mutex); tasklet_goto(&s->tasklet, send); mutex_unlock(&s->mutex); }
MonoStringHandle ves_icall_Mono_Runtime_GetNativeStackTrace (MonoExceptionHandle exc, MonoError *error) { char *trace; MonoStringHandle res; error_init (error); if (MONO_HANDLE_IS_NULL (exc)) { mono_error_set_argument_null (error, "exception", ""); return NULL_HANDLE_STRING; } trace = mono_exception_handle_get_native_backtrace (exc); res = mono_string_new_handle (mono_domain_get (), trace, error); g_free (trace); return res; }
MonoExceptionHandle mono_get_exception_type_initialization_handle (const gchar *type_name, MonoExceptionHandle inner, MonoError *error) { HANDLE_FUNCTION_ENTER (); MonoClass *klass; MonoMethod *method; gpointer iter; error_init (error); klass = mono_class_load_from_name (mono_get_corlib (), "System", "TypeInitializationException"); mono_class_init_internal (klass); iter = NULL; while ((method = mono_class_get_methods (klass, &iter))) { if (!strcmp (".ctor", mono_method_get_name (method))) { MonoMethodSignature *sig = mono_method_signature_internal (method); if (sig->param_count == 2 && sig->params [0]->type == MONO_TYPE_STRING && mono_class_from_mono_type_internal (sig->params [1]) == mono_defaults.exception_class) break; } method = NULL; } g_assert (method); MonoDomain * const domain = mono_domain_get (); MonoStringHandle type_name_str = mono_string_new_handle (domain, type_name, error); mono_error_assert_ok (error); gpointer args [ ] = { MONO_HANDLE_RAW (type_name_str), MONO_HANDLE_RAW (inner) }; MonoObjectHandle exc = mono_object_new_handle (domain, klass, error); mono_error_assert_ok (error); mono_runtime_invoke_handle (method, exc, args, error); goto_if_nok (error, return_null); goto exit; return_null: exc = mono_new_null (); exit: HANDLE_FUNCTION_RETURN_REF (MonoException, MONO_HANDLE_CAST (MonoException, exc)); }
/* note: we better manipulate the string in managed code (easier and safer) */ MonoStringHandle ves_icall_System_Environment_GetOSVersionString (MonoError *error) { error_init (error); #ifdef HOST_WIN32 OSVERSIONINFOEX verinfo; verinfo.dwOSVersionInfoSize = sizeof (OSVERSIONINFOEX); if (GetVersionEx ((OSVERSIONINFO*)&verinfo)) { char version [128]; /* maximum string length is 45 bytes 4 x 10 bytes per number, 1 byte for 0, 3 x 1 byte for dots, 1 for NULL */ sprintf (version, "%ld.%ld.%ld.%d", verinfo.dwMajorVersion, verinfo.dwMinorVersion, verinfo.dwBuildNumber, verinfo.wServicePackMajor << 16); return mono_string_new_handle (mono_domain_get (), version, error); } #elif defined(HAVE_SYS_UTSNAME_H) && defined(_AIX) /* * AIX puts the major version number in .version and minor in .release; so make a * version string based on that; other Unices seem to cram everything in .release * and .version is for things like kernel variants. */ struct utsname name; char version [sizeof(name)]; if (uname (&name) >= 0) { sprintf (version, "%s.%s", name.version, name.release); return mono_string_new_handle (mono_domain_get (), version, error); } #elif defined(HAVE_SYS_UTSNAME_H) struct utsname name; memset (&name, 0, sizeof (name)); // WSL does not always nul terminate. if (uname (&name) >= 0) { return mono_string_new_handle (mono_domain_get (), name.release, error); } #endif return mono_string_new_handle (mono_domain_get (), "0.0.0.0", error); }