bool async_result_handler<T>::check(error_info *error) { if (!m_data->checker(m_data->statuses, m_data->total)) { if (error) { size_t success = 0; dnet_cmd command; command.status = 0; for (auto it = m_data->statuses.begin(); it != m_data->statuses.end(); ++it) { const bool failed_to_send = !(it->flags & DNET_FLAGS_REPLY); const bool ignore_error = failed_to_send && it->status == -ENXIO; if (it->status == 0) { ++success; } else if (command.status == 0 && !ignore_error) { command = *it; } } if (success == 0 && command.status) { *error = create_error(command); } else { *error = create_error(-ENXIO, "insufficient results count due to checker: " "%zu of %zu (%zu)", success, m_data->total, m_data->statuses.size()); } } return false; } if (error) *error = error_info(); return true; }
static HRESULT error_constr(script_ctx_t *ctx, WORD flags, DISPPARAMS *dp, VARIANT *retv, jsexcept_t *ei, DispatchEx *constr) { DispatchEx *err; VARIANT numv; UINT num; BSTR msg = NULL; HRESULT hres; V_VT(&numv) = VT_NULL; if(arg_cnt(dp)) { hres = to_number(ctx, get_arg(dp, 0), ei, &numv); if(FAILED(hres) || (V_VT(&numv)==VT_R8 && isnan(V_R8(&numv)))) hres = to_string(ctx, get_arg(dp, 0), ei, &msg); else if(V_VT(&numv) == VT_I4) num = V_I4(&numv); else num = V_R8(&numv); if(FAILED(hres)) return hres; } if(arg_cnt(dp)>1 && !msg) { hres = to_string(ctx, get_arg(dp, 1), ei, &msg); if(FAILED(hres)) return hres; } switch(flags) { case INVOKE_FUNC: case DISPATCH_CONSTRUCT: if(V_VT(&numv) == VT_NULL) hres = create_error(ctx, constr, NULL, msg, &err); else hres = create_error(ctx, constr, &num, msg, &err); SysFreeString(msg); if(FAILED(hres)) return hres; if(retv) { V_VT(retv) = VT_DISPATCH; V_DISPATCH(retv) = (IDispatch*)_IDispatchEx_(err); } else jsdisp_release(err); return S_OK; default: FIXME("unimplemented flags %x\n", flags); return E_NOTIMPL; } }
static HRESULT throw_error(script_ctx_t *ctx, HRESULT error, const WCHAR *str, jsdisp_t *constr) { WCHAR buf[1024], *pos = NULL; jsdisp_t *err; jsstr_t *msg; HRESULT hres; if(!is_jscript_error(error)) return error; buf[0] = '\0'; LoadStringW(jscript_hinstance, HRESULT_CODE(error), buf, sizeof(buf)/sizeof(WCHAR)); if(str) pos = strchrW(buf, '|'); if(pos) { int len = strlenW(str); memmove(pos+len, pos+1, (strlenW(pos+1)+1)*sizeof(WCHAR)); memcpy(pos, str, len*sizeof(WCHAR)); } WARN("%s\n", debugstr_w(buf)); msg = jsstr_alloc(buf); if(!msg) return E_OUTOFMEMORY; hres = create_error(ctx, constr, error, msg, &err); jsstr_release(msg); if(FAILED(hres)) return hres; jsval_release(ctx->ei.val); ctx->ei.val = jsval_obj(err); return error; }
static HRESULT throw_error(script_ctx_t *ctx, jsexcept_t *ei, UINT id, const WCHAR *str, DispatchEx *constr) { WCHAR buf[1024], *pos = NULL; DispatchEx *err; HRESULT hres; buf[0] = '\0'; LoadStringW(jscript_hinstance, id&0xFFFF, buf, sizeof(buf)/sizeof(WCHAR)); if(str) pos = strchrW(buf, '|'); if(pos) { int len = strlenW(str); memmove(pos+len, pos+1, (strlenW(pos+1)+1)*sizeof(WCHAR)); memcpy(pos, str, len*sizeof(WCHAR)); } WARN("%s\n", debugstr_w(buf)); id |= JSCRIPT_ERROR; hres = create_error(ctx, constr, &id, buf, &err); if(FAILED(hres)) return hres; if(!ei) return id; V_VT(&ei->var) = VT_DISPATCH; V_DISPATCH(&ei->var) = (IDispatch*)_IDispatchEx_(err); return id; }
static int ensure_there_are_changes_to_stash( git_repository *repo, bool include_untracked_files, bool include_ignored_files) { int error; git_status_options opts = GIT_STATUS_OPTIONS_INIT; opts.show = GIT_STATUS_SHOW_INDEX_AND_WORKDIR; if (include_untracked_files) opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED | GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS; if (include_ignored_files) opts.flags = GIT_STATUS_OPT_INCLUDE_IGNORED; error = git_status_foreach_ext(repo, &opts, is_dirty_cb, NULL); if (error == GIT_EUSER) return 0; if (!error) return create_error(GIT_ENOTFOUND, "There is nothing to stash."); return error; }
pascal OSStatus filedsn_setdir_clicked (EventHandlerCallRef inHandlerRef, EventRef inEvent, void *inUserData) { TDSNCHOOSER *choose_t = (TDSNCHOOSER *) inUserData; char msg[4096]; if (!choose_t) return noErr; /* confirm setting a directory */ snprintf (msg, sizeof (msg), "Are you sure that you want to make '%s' the default file DSN directory?", choose_t->curr_dir); if (!create_confirm (choose_t->mainwnd, NULL, msg)) return noErr; /* write FileDSNPath value */ if (!SQLWritePrivateProfileString ("ODBC", "FileDSNPath", choose_t->curr_dir, "odbcinst.ini")) { create_error (choose_t->mainwnd, NULL, "Error setting default file DSN directory", NULL); return noErr; } return noErr; }
pascal OSStatus filedsn_remove_clicked (EventHandlerCallRef inHandlerRef, EventRef inEvent, void *inUserData) { TDSNCHOOSER *choose_t = (TDSNCHOOSER *) inUserData; DataBrowserItemID first, last; OSStatus err; if (!choose_t) return noErr; /* Retrieve the DSN name */ if ((err = GetDataBrowserSelectionAnchor (choose_t->fdsnlist, &first, &last)) == noErr) { if (first > DBITEM_ID && first <= DBITEM_ID + FDSN_nrows) { char str[1024]; char *path; if (FDSN_type[first - DBITEM_ID - 1] == 0) return noErr; /* Get the DSN */ CFStringGetCString(FDSN_array[first - DBITEM_ID - 1], str, sizeof(str), kCFStringEncodingUTF8); asprintf (&path, "%s/%s", choose_t->curr_dir, str); if (path) { if (create_confirm (choose_t->mainwnd, path, "Are you sure you want to remove this File DSN ?")) { /* Call the right function */ if (unlink(path) < 0) { create_error (choose_t->mainwnd, NULL, "Error removing file DSN:", strerror (errno)); } } free(path); addfdsns_to_list (choose_t, choose_t->curr_dir, true); } } } if ((err = GetDataBrowserSelectionAnchor (choose_t->fdsnlist, &first, &last)) == noErr) { if (!first && !last) { DeactivateControl (choose_t->fremove); DeactivateControl (choose_t->fconfigure); DeactivateControl (choose_t->ftest); } } return noErr; }
static int retrieve_head(git_reference **out, git_repository *repo) { int error = git_repository_head(out, repo); if (error == GIT_EORPHANEDHEAD) return create_error(error, "You do not have the initial commit yet."); return error; }
/* * @overload initialize(transaction_id=nil, type=OFPET_HELLO_FAILED, code=OFPHFC_INCOMPATIBLE, user_data=nil) * * @param [Number] transaction_id * a positive number, not recently attached to any previous pending commands to * guarantee message integrity auto-generated if not specified. * * @param [Number] type * a command or action that failed. Defaults to +OFPET_HELLO_FAILED+ if * not specified. * * @param [Number] code * the reason of the failed type error. Defaults to +OFPHFC_INCOMPATIBLE+ if * not specified. * * @param [String] user_data * a more user friendly explanation of the error. Defaults to nil if not * specified. * * @example Instantiate with type and code * Error.new(OFPET_BAD_REQUEST, OFPBRC_BAD_TYPE) * * @example Instantiate with transaction_id, type and code. * Error.new(1234, OFPET_BAD_ACTION, OFPBAC_BAD_VENDOR) * * @example Instantiate with transaction_id, type, code, user_data * Error.new(6789, OFPET_FLOW_MOD_FAILED, OFPFMFC_BAD_EMERG_TIMEOUT, "this is a test") * * @raise [ArgumentError] if transaction id is negative. * @raise [ArgumentError] if user data is not a string. * * @return [Error] * an object that encapsulates the +OFPT_ERROR+ openflow message. */ static VALUE error_new( int argc, VALUE *argv, VALUE klass ) { buffer *data = NULL; uint32_t xid = get_transaction_id(); VALUE xid_r; VALUE user_data; VALUE type_r; VALUE code_r; uint16_t type; uint16_t code; switch ( argc ) { case 2: // type, code specified. rb_scan_args( argc, argv, "02", &type_r, &code_r ); type = ( uint16_t ) NUM2UINT( type_r ); code = ( uint16_t ) NUM2UINT( code_r ); break; case 3: // transaction id, type, code specified. rb_scan_args( argc, argv, "03", &xid_r, &type_r, &code_r ); if ( NUM2INT( xid_r ) < 0 ) { rb_raise( rb_eArgError, "Transaction ID must be >= 0" ); } xid = ( uint32_t ) NUM2UINT( xid_r ); type = ( uint16_t ) NUM2UINT( type_r ); code = ( uint16_t ) NUM2UINT( code_r ); break; case 4: rb_scan_args( argc, argv, "04", &xid_r, &type_r, &code_r, &user_data ); if ( NUM2INT( xid_r ) < 0 ) { rb_raise( rb_eArgError, "Transaction ID must be >= 0" ); } if ( rb_obj_is_kind_of( user_data, rb_cString ) == Qfalse ) { rb_raise( rb_eArgError, "User data must be a string" ); } xid = ( uint32_t ) NUM2UINT( xid_r ); type = ( uint16_t ) NUM2UINT( type_r ); code = ( uint16_t ) NUM2UINT( code_r ); uint16_t length = ( u_int16_t ) RSTRING_LEN( user_data ); data = alloc_buffer_with_length( length ); void *p = append_back_buffer( data, length ); memcpy( p, RSTRING_PTR( user_data ), length ); break; default: type = OFPET_HELLO_FAILED; code = OFPHFC_INCOMPATIBLE; break; } buffer *error = create_error( xid, type, code, data ); if ( data != NULL ) { free_buffer( data ); } return Data_Wrap_Struct( klass, NULL, free_buffer, error ); }
/* * call-seq: * nwfilter.uuid -> string * * Call +virNWFilterGetUUIDString+[http://www.libvirt.org/html/libvirt-libvirt.html#virNWFilterGetUUIDString] * to retrieve the network filter UUID. */ static VALUE libvirt_nwfilter_uuid(VALUE s) { virNWFilterPtr nwfilter = nwfilter_get(s); int r; char uuid[VIR_UUID_STRING_BUFLEN]; r = virNWFilterGetUUIDString(nwfilter, uuid); _E(r < 0, create_error(e_RetrieveError, "virNWFilterGetUUIDString", conn(s))); return rb_str_new2((char *)uuid); }
/* open callback */ static int kplugs_open(struct inode *inode, struct file *filp) { int err = 0; if (!capable(CAP_SYS_MODULE)) { return -EPERM; } /* create a new context for this file descriptor */ err = context_create((context_t **)&filp->private_data); return err ? create_error(NULL, err) : 0; }
static HRESULT error_constr(script_ctx_t *ctx, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r, jsdisp_t *constr) { jsdisp_t *err; UINT num = 0; jsstr_t *msg = NULL; HRESULT hres; if(argc) { double n; hres = to_number(ctx, argv[0], &n); if(FAILED(hres)) /* FIXME: really? */ n = NAN; if(isnan(n)) hres = to_string(ctx, argv[0], &msg); if(FAILED(hres)) return hres; num = n; } if(!msg) { if(argc > 1) { hres = to_string(ctx, argv[1], &msg); if(FAILED(hres)) return hres; }else { msg = jsstr_empty(); } } switch(flags) { case INVOKE_FUNC: case DISPATCH_CONSTRUCT: hres = create_error(ctx, constr, num, msg, &err); jsstr_release(msg); if(FAILED(hres)) return hres; if(r) *r = jsval_obj(err); else jsdisp_release(err); return S_OK; default: if(msg) jsstr_release(msg); FIXME("unimplemented flags %x\n", flags); return E_NOTIMPL; } }
p_data_t creater_t::create_argument_number_error( const std::string& name,size_t min_number,size_t got_number,bool is_kahencho) { std::string message="invalid number of arguments for "+name+" : expected "; char buffer[16]; if(is_kahencho) { message+=" at least "; } sprintf(buffer,"%u",(unsigned int)min_number); message+=buffer; message+=", got "; sprintf(buffer,"%u",(unsigned int)got_number); message+=buffer; return create_error(message); }
int ofpmsg_send_error_msg( struct switch_info *sw_info, uint16_t type, uint16_t code, buffer *data ) { int ret; buffer *buf; if (data->length > OFP_ERROR_MSG_MAX_DATA ) { // FIXME data->length = OFP_ERROR_MSG_MAX_DATA; } buf = create_error( generate_xid(), type, code, data ); ret = send_to_secure_channel( sw_info, buf ); if ( ret == 0 ) { debug( "Send 'error' to a switch %#" PRIx64 ".", sw_info->datapath_id ); } return ret; }
void server_node::start() { if (is_started()) throw std::runtime_error("Server node \"" + m_path + "\" is already started"); if (m_fork) { m_kill_sent = false; m_pid = fork(); if (m_pid == -1) { m_pid = 0; int err = -errno; throw_error(err, "Failed to fork process"); } else if (m_pid == 0) { char buffer[3][1024] = { " ", "-c" }; std::string ios_path = ioserv_path(); char * const args[] = { const_cast<char*>(ios_path.c_str()), buffer[1], const_cast<char*>(m_path.c_str()), NULL }; auto ld_path = std::string("LD_LIBRARY_PATH=") + getenv("LD_LIBRARY_PATH"); char * const env[] = { const_cast<char*>(ld_path.c_str()), NULL }; if (execve(ios_path.data(), args, env) == -1) { int err = -errno; std::cerr << create_error(err, "Failed to start process \"%s\"", ios_path.c_str()).message() << std::endl; quick_exit(1); } } } else { m_node = dnet_parse_config(m_path.c_str(), 0); } if (!is_started()) throw std::runtime_error("Can not start server with config file: \"" + m_path + "\""); }
void create_errorw (HWND hwnd, LPCWSTR dsn, LPCWSTR text, LPCWSTR errmsg) { LPSTR _dsn = NULL; LPSTR _text = NULL; LPSTR _errmsg = NULL; _dsn = dm_SQL_WtoU8(dsn, SQL_NTS); _text = dm_SQL_WtoU8(text, SQL_NTS); _errmsg = dm_SQL_WtoU8(errmsg, SQL_NTS); create_error(hwnd, _dsn, _text, _errmsg); if (_dsn) free(_dsn); if (_text) free(_text); if (_errmsg) free(_errmsg); }
int main(int ac, char **av) { int i; if (ac > 1) { i = 1; while (i < ac) { if (ac != 2) put_file_path(av[i]); solve_map(av[i++]); } } else { generate_map(); solve_map(MAP_PATH); if ((i = open(MAP_PATH, O_TRUNC)) <= 0) create_error(MAP_PATH); close(i); } return (0); }
void addfdsns_to_list (TDSNCHOOSER *dsnchoose_t, char *path, Boolean b_reset) { DataBrowserItemID item = DBITEM_ID + 1; DataBrowserCallbacks dbCallbacks; ThemeDrawingState outState = NULL; UInt16 colSize[3] = { 400, 100, 150 }; SInt16 outBaseline; Point ioBound; int i; DIR *dir; char *path_buf; struct dirent *dir_entry; struct stat fstat; int b_added; ControlRef widget; WindowRef dlg; if (!dsnchoose_t || !path) return; widget = dsnchoose_t->fdsnlist; dlg = dsnchoose_t->mainwnd; GetThemeDrawingState (&outState); /* Install an event handler on the component databrowser */ dbCallbacks.version = kDataBrowserLatestCallbacks; InitDataBrowserCallbacks (&dbCallbacks); dbCallbacks.u.v1.itemNotificationCallback = NewDataBrowserItemNotificationUPP (fdsn_notification_item); /* On Mac OS X 10.0.x : clientDataCallback */ dbCallbacks.u.v1.itemDataCallback = NewDataBrowserItemDataUPP (fdsn_getset_item); SetDataBrowserCallbacks (widget, &dbCallbacks); /* Begin the draw of the data browser */ SetDataBrowserTarget (widget, DBITEM_ID); /* Make the clean up */ for (i = 0; i < FDSN_nrows; i++, item++) { CFRelease (FDSN_array[i]); FDSN_array[i] = NULL; FDSN_type[i] = 0; RemoveDataBrowserItems (widget, DBITEM_ID, 1, &item, DBNAME_ID); } ActivateControl (widget); DrawOneControl (widget); /* Global Initialization */ FDSN_nrows = 0; item = DBITEM_ID + 1; if ((dir = opendir (path))) { while ((dir_entry = readdir (dir)) && FDSN_nrows < MAX_ROWS) { asprintf (&path_buf, "%s/%s", path, dir_entry->d_name); b_added = 0; if (stat ((LPCSTR) path_buf, &fstat) >= 0 && S_ISDIR (fstat.st_mode)) { if (dir_entry->d_name && dir_entry->d_name[0] != '.') { FDSN_array[FDSN_nrows] = CFStringCreateWithCString(NULL, dir_entry->d_name, kCFStringEncodingUTF8); FDSN_type[FDSN_nrows] = 0; b_added = 1; } } else if (stat ((LPCSTR) path_buf, &fstat) >= 0 && !S_ISDIR (fstat.st_mode) && strstr (dir_entry->d_name, ".dsn")) { FDSN_array[FDSN_nrows] = CFStringCreateWithCString(NULL, dir_entry->d_name, kCFStringEncodingUTF8); FDSN_type[FDSN_nrows] = 1; b_added = 1; } if (path_buf) free (path_buf); if (b_added) { GetThemeTextDimensions (FDSN_array[FDSN_nrows], kThemeSystemFont, kThemeStateActive, false, &ioBound, &outBaseline); if(colSize[0] < ioBound.h) colSize[0] = ioBound.h; AddDataBrowserItems (widget, DBITEM_ID, 1, &item, DBNAME_ID); item++; FDSN_nrows++; } } /* Close the directory entry */ closedir (dir); } else create_error (NULL, NULL, "Error during accessing directory information", strerror (errno)); ActivateControl (widget); /* Resize the columns to have a good look */ SetDataBrowserTableViewNamedColumnWidth (widget, DBNAME_ID, colSize[0] + 20); DrawOneControl (widget); /* Remove the DataBrowser callback */ SetDataBrowserCallbacks (NULL, &dbCallbacks); if(outState) DisposeThemeDrawingState (outState); if (b_reset) SetDataBrowserScrollPosition(widget, 0, 0); fill_dir_menu(dsnchoose_t, path); }
static VALUE error_alloc( VALUE klass ) { buffer *error = create_error( 0, 0, 0, NULL ); return Data_Wrap_Struct( klass, NULL, free_buffer, error ); }
connection::pointer node::connect(const std::string &addr_str, typename connection::process_fn_t process) { connection::pointer cn = connection::create(m_io_pool, process, std::bind(&node::drop, this, std::placeholders::_1, std::placeholders::_2)); auto it = m_resolver.resolve(addr_str); cn->connect(it); auto id = cn->ids()[0]; VLOG(2) << "connection: " << cn->connection_string() << ", node has been connected"; if (m_route.add(cn)) { cn->close(); auto dump = [] (const std::vector<connection::cid_t> &cids) { std::ostringstream ss; for (auto &id: cids) { ss << id; if (id != cids.back()) ss << ","; } return ss.str(); }; for (auto cn: m_route.connections()) { VLOG(2) << "connection: " << cn->connection_string() << ", routes: " << dump(cn->ids()); } return m_route.find(id); } std::promise<int> p; std::future<int> f = p.get_future(); std::vector<address> addrs; cn->request_remote_nodes([&] (connection::pointer, message &msg) { if (msg.hdr.status) { LOG(ERROR) << "connection: " << cn->connection_string() << ", reply: " << msg.to_string() << ", error: could not request remote connections"; p.set_exception(std::make_exception_ptr( create_error(msg.hdr.status, "connect: could not request remote connections"))); return; } try { msgpack::unpacked up; msgpack::unpack(&up, msg.data(), msg.hdr.size); up.get().convert(&addrs); p.set_value(0); } catch (const std::exception &e) { LOG(ERROR) << "connection: " << cn->connection_string() << ", message: " << msg.to_string() << ", error: could not unpack array of endpoints: " << e.what(); p.set_exception(std::current_exception()); return; } }); f.get(); for (auto &addr: addrs) { LOG(INFO) << "received address: " << addr.to_string(); if (addr.endpoint() == cn->socket().remote_endpoint()) continue; auto eps_it = connection::resolver_iterator::create(addr.endpoint(), addr.host(), std::to_string(addr.port())); connection::pointer c = connection::create(m_io_pool, process, std::bind(&node::drop, this, std::placeholders::_1, std::placeholders::_2)); c->connect(eps_it); VLOG(2) << "connection: " << c->connection_string() << ", node has been connected"; if (m_route.add(c)) { c->close(); } } return cn; }
/* the module init function */ static int __init kplugs_init(void) { int err = 0; struct device *device = NULL; memory_start(); err = context_create(&GLOBAL_CONTEXT); if (err < 0) { output_string("Couldn't create the global context.\n"); ERROR_CLEAN(create_error(NULL, err)); } err = alloc_chrdev_region(&kplugs_devno , 0, 1, DEVICE_NAME); if (err < 0) { output_string("Couldn't allocate a region.\n"); ERROR_CLEAN(create_error(NULL, err)); } kplugs_class = class_create(THIS_MODULE, DEVICE_NAME); if (NULL == kplugs_class) { output_string("Couldn't create class.\n"); ERROR_CLEAN(-ENOMEM); } kplugs_cdev = cdev_alloc(); if (NULL == kplugs_cdev) { output_string("Couldn't allocate a cdev.\n"); ERROR_CLEAN(-ENOMEM); } cdev_init(kplugs_cdev, &kplugs_ops); err = cdev_add(kplugs_cdev, kplugs_devno, 1); if (err < 0) { output_string("Couldn't add the cdev.\n"); ERROR_CLEAN(create_error(NULL, err)); } device = device_create(kplugs_class, NULL, kplugs_devno, NULL, DEVICE_NAME); if (device == NULL) { output_string("Couldn't create the device.\n"); ERROR_CLEAN(-ENOMEM); } return 0; clean: if (NULL != kplugs_cdev) { cdev_del(kplugs_cdev); } if (NULL != kplugs_class) { class_destroy(kplugs_class); } if (kplugs_devno) { unregister_chrdev_region(kplugs_devno, 1); } if (NULL != GLOBAL_CONTEXT) { context_free(GLOBAL_CONTEXT); } memory_stop(); return err; }
pascal OSStatus filedsn_configure_clicked (EventHandlerCallRef inHandlerRef, EventRef inEvent, void *inUserData) { TDSNCHOOSER *choose_t = (TDSNCHOOSER *) inUserData; DataBrowserItemID first, last; OSStatus err; char str[1024], path[1024]; int id; char *drv = NULL; char *attrs = NULL; char *_attrs = NULL; /* attr list */ size_t len = 0; /* current attr list length (w/o list-terminating NUL) */ char *p, *p_next; WORD read_len; char entries[4096]; char *curr_dir; if (!choose_t) return noErr; curr_dir = choose_t->curr_dir; /* Retrieve the DSN name */ if ((err = GetDataBrowserSelectionAnchor (choose_t->fdsnlist, &first, &last)) == noErr) { if (first > DBITEM_ID && first <= DBITEM_ID + FDSN_nrows) { id = first - DBITEM_ID - 1; CFStringGetCString(FDSN_array[id], str, sizeof(str), kCFStringEncodingUTF8); if (*curr_dir == '/' && strlen(curr_dir) == 1) snprintf(path, sizeof(path), "/%s", str); else snprintf(path, sizeof(path), "%s/%s", curr_dir, str); if (FDSN_type[id] == 0) /* Directory */ { addfdsns_to_list (choose_t, path, true); } else /* File DSN*/ { /* Get list of entries in .dsn file */ if (!SQLReadFileDSN (path, "ODBC", NULL, entries, sizeof (entries), &read_len)) { create_error (choose_t->mainwnd, NULL, "SQLReadFileDSN failed", NULL); goto done; } /* add params from the .dsn file */ for (p = entries; *p != '\0'; p = p_next) { char *tmp; size_t add_len; /* length of added attribute */ char value[1024]; /* get next entry */ p_next = strchr (p, ';'); if (p_next) *p_next++ = '\0'; if (!SQLReadFileDSN (path, "ODBC", p, value, sizeof(value), &read_len)) { create_error (choose_t->mainwnd, NULL, "SQLReadFileDSN failed", NULL); goto done; } if (!strcasecmp (p, "DRIVER")) { /* got driver keyword */ add_len = strlen ("DRIVER=") + strlen (value) + 1; drv = malloc (add_len); snprintf (drv, add_len, "DRIVER=%s", value); continue; } /* +1 for '=', +1 for NUL */ add_len = strlen (p) + 1 + strlen (value) + 1; /* +1 for list-terminating NUL */; tmp = realloc (attrs, len + add_len + 1); if (tmp == NULL) { create_error (choose_t->mainwnd, NULL, "Error adding file DSN:", strerror (errno)); goto done; } attrs = tmp; snprintf (attrs + len, add_len, "%s=%s", p, value); len += add_len; } if (drv == NULL) { /* no driver found, probably unshareable file data source */ create_error (choose_t->mainwnd, NULL, "Can't configure file DSN without DRIVER keyword (probably unshareable data source?)", NULL); goto done; } if (attrs == NULL) attrs = "\0\0"; else { /* NUL-terminate the list */ attrs[len] = '\0'; _attrs = attrs; } /* Configure file DSN */ filedsn_configure (choose_t, drv, path, attrs, FALSE, TRUE); addfdsns_to_list (choose_t, curr_dir, true); } } } done: if (drv != NULL) free (drv); if (_attrs != NULL) free (_attrs); if ((err = GetDataBrowserSelectionAnchor (choose_t->sdsnlist, &first, &last)) == noErr) { if (!first && !last) { DeactivateControl (choose_t->sremove); DeactivateControl (choose_t->sconfigure); DeactivateControl (choose_t->stest); } } return noErr; }
/* write callback */ static ssize_t kplugs_write(struct file *filp, const char *buf, size_t count, loff_t *f_pos) { kplugs_command_t *cmd = NULL; context_t *file_cont = NULL; context_t *cont = NULL; bytecode_t *code = NULL; function_t *func = NULL; exception_t excep; stack_t stack; word iter, arg; word args; byte little_endian; byte func_name[MAX_FUNC_NAME + 1]; int err = 0; #ifdef __LITTLE_ENDIAN little_endian = 1; #else little_endian = 0; #endif /* get the user's command */ cmd = (kplugs_command_t *)buf; file_cont = (context_t *)filp->private_data; if (count < sizeof(byte) * 3) { /* three bytes of header */ return create_error(file_cont, -ERROR_PARAM); } if (cmd->word_size != sizeof(word) || cmd->l_endian != little_endian) { return create_error(file_cont, -ERROR_ARCH); } if (cmd->version_major != VERSION_MAJOR || cmd->version_minor != VERSION_MINOR) { return create_error(file_cont, -ERROR_VERSION); } if (count != sizeof(kplugs_command_t)) { return create_error(file_cont, -ERROR_PARAM); } cont = cmd->is_global ? GLOBAL_CONTEXT : file_cont; switch (cmd->type) { case KPLUGS_LOAD: /* load a new function */ if (cmd->len2 != 0 || cmd->ptr2 != NULL) { return create_error(file_cont, -ERROR_PARAM); } code = memory_alloc(cmd->len1); if (NULL == code) { ERROR(create_error(file_cont, -ERROR_MEM)); } err = memory_copy_from_outside(code, cmd->uptr1, cmd->len1); if (err < 0) { err = create_error(file_cont, err); goto clean; } /* create the function */ err = function_create(code, cmd->len1, &func); if (err < 0) { err = create_error(file_cont, err); goto clean; } err = context_add_function(cont, func); if (err < 0) { err = create_error(file_cont, err); goto clean; } /* return the function's address */ context_create_reply(file_cont, (word)&func->func_code, NULL); return count; case KPLUGS_UNLOAD: /* unload a function with a name */ if (NULL != cmd->uptr2) { return create_error(file_cont, -ERROR_PARAM); } case KPLUGS_EXECUTE: /* execute (and unload) a function with a name */ if (cmd->len1 > MAX_FUNC_NAME || (cmd->len2 % sizeof(word)) != 0) { return create_error(file_cont, -ERROR_PARAM); } err = memory_copy_from_outside(func_name, cmd->uptr1, cmd->len1); if (err < 0) { return create_error(file_cont, err); } func_name[cmd->len1] = '\0'; /* find the function */ if (cmd->type == KPLUGS_UNLOAD) { func = context_find_function(cont, func_name); if (NULL == func) { return create_error(file_cont, -ERROR_UFUNC); } /* delete the function */ context_free_function(func); err = (int)count; goto clean; } if (!cmd->is_global) { func = context_find_function(file_cont, func_name); } if (NULL == func) { func = context_find_function(GLOBAL_CONTEXT, func_name); if (NULL == func) { return create_error(file_cont, -ERROR_UFUNC); } } goto execute_func; case KPLUGS_UNLOAD_ANONYMOUS: /* unload an anonymous function */ if (NULL != cmd->uptr2 || cmd->len1 || cmd->len2) { return create_error(file_cont, -ERROR_PARAM); } func = context_find_anonymous(cont, cmd->ptr1); if (NULL == func) { return create_error(file_cont, -ERROR_UFUNC); } /* delete the function */ context_free_function(func); err = (int)count; goto clean; break; case KPLUGS_EXECUTE_ANONYMOUS: /* execute (and unload) an anonymous function */ if (cmd->len1 || (cmd->len2 % sizeof(word)) != 0) { return create_error(file_cont, -ERROR_PARAM); } /* find the function */ if (!cmd->is_global) { func = context_find_anonymous(file_cont, cmd->ptr1); } if (NULL == func) { func = context_find_anonymous(GLOBAL_CONTEXT, cmd->ptr1); if (NULL == func) { return create_error(file_cont, -ERROR_UFUNC); } } execute_func: /* do the execution of a function: */ args = cmd->len2 / sizeof(word); if (args > func->num_maxargs || args < func->num_minargs) { ERROR_CLEAN(create_error(file_cont, -ERROR_ARGS)); } err = stack_alloc(&stack, sizeof(word), CALL_STACK_SIZE); if (err < 0) { err = create_error(file_cont, err); goto clean; } /* push the arguments to a stack */ for (iter = 0; iter < args; ++iter) { err = memory_copy_from_outside(&arg, cmd->ptr2 + (iter * sizeof(word)), sizeof(arg)); if (err < 0) { stack_free(&stack); err = create_error(file_cont, err); goto clean; } if (NULL == stack_push(&stack, &arg)) { stack_free(&stack); ERROR_CLEAN(create_error(file_cont, -ERROR_MEM)); } } /* execute the function and create an answer */ arg = vm_run_function(func, &stack, &excep); stack_free(&stack); if (excep.had_exception) { err = -EINVAL; /* it dosen't really matter which error. the value of the error will be taken from the answer */ arg = excep.value; } else { err = (int)count; } context_create_reply(file_cont, arg, &excep); goto clean; case KPLUGS_GET_LAST_EXCEPTION: if (NULL != cmd->uptr2 || cmd->len1 < sizeof(exception_t) || cmd->len2) { ERROR(create_error(file_cont, -ERROR_PARAM)); } err = context_get_last_exception(file_cont, (exception_t *)cmd->ptr1); if (err < 0) { return create_error(file_cont, err); } return count; default: return create_error(file_cont, -ERROR_PARAM); } clean: if (NULL != func) { function_put(func); } else if (NULL != code) { memory_free(code); } return err; }
texception::texception(const std::string& operation, const bool use_sdl_error) : game::error(create_error(operation, use_sdl_error)) { }
error_info create_error(const dnet_cmd &cmd) { return create_error(cmd.status, cmd.id, "Failed to process %s command", dnet_cmd_string(cmd.cmd)); }
static void filedsn_configure (TDSNCHOOSER *choose_t, char *drv, char *dsn, char *in_attrs, BOOL b_add, BOOL verify_conn) { char *connstr = NULL; size_t len; /* current connstr len */ size_t add_len; /* len of appended string */ LPSTR attrs = NULL, curr, tmp, attr_lst = NULL; BOOL b_Save = TRUE; attrs = in_attrs; if (!b_add && !_CheckDriverLoginDlg(drv + STRLEN("DRIVER="))) { /* Get DSN name and additional attributes */ attr_lst = create_gensetup (choose_t->mainwnd, dsn, in_attrs, b_add, &verify_conn); attrs = attr_lst; } if (!attrs) { create_error (choose_t->mainwnd, NULL, "Error adding File DSN:", strerror (ENOMEM)); return; } if (attrs == (LPSTR) - 1L) return; /* Build the connection string */ connstr = strdup (drv); len = strlen (connstr); for (curr = attrs; *curr; curr += (STRLEN (curr) + 1)) { if (!strncasecmp (curr, "DSN=", STRLEN ("DSN="))) { if (dsn == NULL) { /* got dsn name */ dsn = curr + STRLEN ("DSN="); } continue; } /* append attr */ add_len = 1 + strlen (curr); /* +1 for ';' */ tmp = realloc (connstr, len + add_len + 1); /* +1 for NUL */ if (tmp == NULL) { create_error (choose_t->mainwnd, NULL, "Error adding File DSN:", strerror (errno)); goto done; } connstr = tmp; snprintf (connstr + len, add_len + 1, ";%s", curr); len += add_len; } /* Nothing to do if no DSN */ if (!dsn || STRLEN (dsn) == 0) goto done; if (verify_conn) { BOOL ret; /* Append SAVEFILE */ add_len = strlen (";SAVEFILE=") + strlen (dsn); tmp = realloc (connstr, len + add_len + 1); /* +1 for NUL */ if (tmp == NULL) { create_error (choose_t->mainwnd, NULL, "Error adding file DSN:", strerror (errno)); goto done; } connstr = tmp; snprintf (connstr + len, add_len + 1, ";SAVEFILE=%s", dsn); len += add_len; /* Connect to data source */ ret = test_driver_connect (choose_t, connstr); if (!ret && b_add) { if (create_confirm (choose_t->mainwnd, dsn, "Can't check the connection. Do you want to store the FileDSN without verification ?")) b_Save = TRUE; else b_Save = FALSE; } else b_Save = FALSE; } if (b_Save) { char key[512]; char *p; size_t sz; if (drv) { p = strchr(drv, '='); if (!SQLWriteFileDSN (dsn, "ODBC", "DRIVER", p + 1)) { create_error (choose_t->mainwnd, NULL, "Error adding File DSN:", strerror (errno)); goto done; } } for (curr = attrs; *curr; curr += (STRLEN (curr) + 1)) { if (!strncasecmp (curr, "DSN=", STRLEN ("DSN="))) continue; else if (!strncasecmp (curr, "PWD=", STRLEN ("PWD="))) continue; else if (!strncasecmp (curr, "SAVEFILE=", STRLEN ("SAVEFILE="))) continue; else if (!strncasecmp (curr, "FILEDSN=", STRLEN ("FILEDSN="))) continue; p = strchr(curr, '='); sz = p - curr < sizeof(key) ? p - curr : sizeof(key); memset(key, 0, sizeof(key)); strncpy(key, curr, sz); if (!SQLWriteFileDSN (dsn, "ODBC", key, p + 1)) { create_error (choose_t->mainwnd, NULL, "Error adding File DSN:", strerror (errno)); goto done; } } } done: if (attr_lst != NULL) free (attr_lst); if (connstr != NULL) free (connstr); }