setError(xmlrpc_env * const envP, const char format[], ...) { va_list args; const char * faultString; va_start(args, format); cvasprintf(&faultString, format, args); va_end(args); xmlrpc_env_set_fault(envP, XMLRPC_INTERNAL_ERROR, faultString); strfree(faultString); }
int dmu_objset_snapshot_one(const char *fsname, const char *snapname) { int err; char *longsnap = kmem_asprintf("%s@%s", fsname, snapname); nvlist_t *snaps = fnvlist_alloc(); fnvlist_add_boolean(snaps, longsnap); strfree(longsnap); err = dsl_dataset_snapshot(snaps, NULL, NULL); fnvlist_free(snaps); return (err); }
/* Return 0 if not found, 1 if found and removed */ int remove_loop(char *cmd_name) { Loop *p; int val; if (*cmd_name == '#') { val = atoi(cmd_name + 1); p = loop_info.head; while (p && (p->indx != val)) { p = p->next; } } else { p = find_loop(cmd_name); } if (!p) { return false; } /* Head of list? */ if (!p->prev) { /* Not sole node */ if (p->next) { loop_info.head = p->next; loop_info.head->prev = (Loop *)NULL; } else { /* Sole node */ loop_info.head = (Loop *)NULL; loop_info.tail = (Loop *)NULL; } } else if (!p->next) { /* End of list */ loop_info.tail = p->prev; p->prev->next = (Loop *)NULL; } else { /* Middle of list */ p->prev->next = p->next; p->next->prev = p->prev; } if (p->time == loop_info.low_time) { loop_update_time(); } strfree(p->cmd); free(p); loop_update_index(); return true; }
static void determineBackgroundColor(struct pam * const pamP, bool const verbose, tuple * const bgColorP) { /*---------------------------------------------------------------------------- Determine what color is the background color of the image in the file represented by *pamP. Expect the file to be positioned to the start of the raster, and leave it positioned arbitrarily. -----------------------------------------------------------------------------*/ unsigned int row; tuple * tuplerow; tuple ul, ur, ll, lr; /* Color of upper left, upper right, lower left, lower right */ tuplerow = pnm_allocpamrow(pamP); ul = pnm_allocpamtuple(pamP); ur = pnm_allocpamtuple(pamP); ll = pnm_allocpamtuple(pamP); lr = pnm_allocpamtuple(pamP); pnm_readpamrow(pamP, tuplerow); pnm_assigntuple(pamP, ul, tuplerow[0]); pnm_assigntuple(pamP, ur, tuplerow[pamP->width-1]); for (row = 1; row < pamP->height; ++row) pnm_readpamrow(pamP, tuplerow); pnm_assigntuple(pamP, ll, tuplerow[0]); pnm_assigntuple(pamP, lr, tuplerow[pamP->width-1]); selectBackground(pamP, ul, ur, ll, lr, bgColorP); if (verbose) { int const hexokTrue = 1; const char * const colorname = pnm_colorname(pamP, *bgColorP, hexokTrue); pm_message("Background color is %s", colorname); strfree(colorname); } pnm_freepamtuple(lr); pnm_freepamtuple(ll); pnm_freepamtuple(ur); pnm_freepamtuple(ul); pnm_freepamrow(tuplerow); }
/*============================ * menuitem_terminate_worker -- free menu arrays *==========================*/ void menuitem_terminate (void) { INT i; if (!f_reloading) { register_brwsmenu_lang_callbacks(FALSE); } for (i=1; i<=MAX_SCREEN; i++) { struct BrowseScreenInfo * sinfo=&f_BrowseScreenInfo[i]; dynmenu_clear(&sinfo->dynmenu); strfree(&sinfo->title); } f_initialized = FALSE; }
/* * Used by file systems when fs-specific nodes (e.g., ufs inodes) are * cached by the file system and vnodes remain associated. */ void vn_recycle(vnode_t *vp) { ASSERT(vp->v_fd == -1); vp->v_rdcnt = 0; vp->v_wrcnt = 0; if (vp->v_path) { strfree(vp->v_path); vp->v_path = NULL; } }
/*ARGSUSED*/ int cmd_oldbp(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { char *s = mdb_argv_to_str(argc, argv); if (mdb_tgt_add_vbrkpt(mdb.m_target, addr, 0, cmd_event, s) == 0) { mdb_warn("failed to add breakpoint"); if (s != NULL) strfree(s); return (DCMD_ERR); } return (DCMD_OK); }
static void test_parse_xml_call(void) { xmlrpc_env env; const char *method_name; xmlrpc_value *params; int i1, i2; const char **bad_call; xml_element *elem; xmlrpc_env_init(&env); /* Parse a valid call. */ xmlrpc_parse_call(&env, serialized_call, strlen(serialized_call), &method_name, ¶ms); TEST_NO_FAULT(&env); TEST(params != NULL); xmlrpc_decompose_value(&env, params, "(ii)", &i1, &i2); xmlrpc_DECREF(params); TEST_NO_FAULT(&env); TEST(streq(method_name, "gloom&doom")); TEST(i1 == 10 && i2 == 20); strfree(method_name); /* Test some poorly-formed XML data. */ xmlrpc_parse_call(&env, unparseable_value, strlen(unparseable_value), &method_name, ¶ms); TEST_FAULT(&env, XMLRPC_PARSE_ERROR); TEST(method_name == NULL && params == NULL); /* Next, check for bogus values. These are all well-formed XML, but they aren't legal XML-RPC. */ for (bad_call = bad_calls; *bad_call != NULL; ++bad_call) { /* First, check to make sure that our test case is well-formed XML. ** (It's easy to make mistakes when writing the test cases!) */ xml_parse(&env, *bad_call, strlen(*bad_call), &elem); TEST_NO_FAULT(&env); xml_element_free(elem); /* Now, make sure the higher-level routine barfs appropriately. */ xmlrpc_parse_call(&env, *bad_call, strlen(*bad_call), &method_name, ¶ms); TEST_FAULT(&env, XMLRPC_PARSE_ERROR); TEST(method_name == NULL && params == NULL); } xmlrpc_env_clean(&env); }
/*ARGSUSED*/ static int oldwp(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv, uint_t rwx) { char *s = mdb_argv_to_str(argc, argv); if (mdb_tgt_add_vwapt(mdb.m_target, addr, mdb.m_dcount, rwx, 0, cmd_event, s) == 0) { mdb_warn("failed to add watchpoint"); if (s != NULL) strfree(s); return (DCMD_ABORT); } return (DCMD_ABORT); /* we use m_dcount as an argument; don't loop */ }
char const * strgeti(char const *s) { char *str = strnew(strlen(s)); char *p = str; const char *ret; for (; *s != '\0'; s++) *p++ = (isupper(*s)) ? tolower(*s) : *s; *p = '\0'; ret = strget(str); strfree(str); return ret; }
char *setsval(register cell *vp, const char *s) { dprintf("setsval: %lo %s\n", (long)vp, s); checkval(vp); if (vp == recloc) error(FATAL, "can't set $0"); vp->tval &= ~NUM; vp->tval |= STR; if ((vp->tval & FLD) && isnull(vp->nval)) donerec = 0; if (!(vp->tval&FLD)) strfree(vp->sval); vp->tval &= ~FLD; return(vp->sval = tostring(s)); }
SCRN *clearmem(SCRN *lp,int cnt) { register unsigned i; SCRN *cp; if(cnt == EOF) { i= 0; --i; } else i= cnt; while(i-- && lp != (SCRN *)NULL) { strfree(lp->buffer); cp= lp; lp= lp->fwd; linefree(cp); } return(lp); }
tupletable pnm_alloctupletable(const struct pam * const pamP, unsigned int const size) { tupletable retval; const char * error; alloctupletable(pamP, size, &retval, &error); if (error) { strfree(error); pm_error("Failed to allocation tuple table of size %u", size); } return retval; }
int main(int const argc, const char ** const argv) { struct cmdlineInfo cmdline; xmlrpc_env env; xmlrpc_mem_block * callXmlP; xmlrpc_mem_block * respXmlP; const char * url; xmlrpc_server_info * serverInfoP; xmlrpc_env_init(&env); parseCommandLine(&env, argc, argv, &cmdline); die_if_fault_occurred(&env); computeUrl(cmdline.url, &url); createServerInfo(&env, url, cmdline.username, cmdline.password, &serverInfoP); die_if_fault_occurred(&env); fprintf(stderr, "Reading call data from Standard Input...\n"); readFile(&env, stdin, &callXmlP); die_if_fault_occurred(&env); fprintf(stderr, "Making call...\n"); doCall(&env, cmdline.transport, serverInfoP, callXmlP, &respXmlP); die_if_fault_occurred(&env); fprintf(stderr, "Writing response data to Standard Output\n"); writeFile(&env, stdout, respXmlP); die_if_fault_occurred(&env); XMLRPC_MEMBLOCK_FREE(char, callXmlP); XMLRPC_MEMBLOCK_FREE(char, respXmlP); strfree(url); freeCmdline(cmdline); xmlrpc_env_clean(&env); return 0; }
tupletable pnm_alloctupletable(const struct pam * const pamP, unsigned int const size) { tupletable retval; const char * error; alloctupletable(pamP, size, &retval, &error); if (error) { pm_errormsg("%s", error); strfree(error); pm_longjmp(); } return retval; }
static int __zpl_xattr_security_set(struct inode *ip, const char *name, const void *value, size_t size, int flags) { char *xattr_name; int error; if (strcmp(name, "") == 0) return -EINVAL; xattr_name = kmem_asprintf("%s%s", XATTR_SECURITY_PREFIX, name); error = zpl_xattr_set(ip, xattr_name, value, size, flags); strfree(xattr_name); return (error); }
int main(int argc, const char ** argv) { xmlrpc_env env; const char * methodName; xmlrpc_value * paramArrayP; xmlrpc_mem_block * callXmlP; if (argc-1 > 0) { fprintf(stderr, "No arguments. Input is from Standard Input\n"); if (argv){} /* defeat compiler warning */ exit(99); } xmlrpc_env_init(&env); fprintf(stderr, "Reading call data from Standard Input...\n"); readFile(&env, stdin, &callXmlP); die_if_fault_occurred(&env); xmlrpc_parse_call(&env, XMLRPC_MEMBLOCK_CONTENTS(char, callXmlP), XMLRPC_MEMBLOCK_SIZE(char, callXmlP), &methodName, ¶mArrayP); if (env.fault_occurred) printf("Invalid call. %s\n", env.fault_string); else { printf("Parsed successfully as XML-RPC call.\n"); printf("Method name: '%s'\n", methodName); printf("Parameter array:\n"); dumpValue(" ", paramArrayP); strfree(methodName); xmlrpc_DECREF(paramArrayP); } XMLRPC_MEMBLOCK_FREE(char, callXmlP); xmlrpc_env_clean(&env); return 0; }
int kt_setflags(mdb_tgt_t *t, int flags) { int iochg = ((flags ^ t->t_flags) & MDB_TGT_F_ALLOWIO) && !mdb_prop_postmortem; int rwchg = (flags ^ t->t_flags) & MDB_TGT_F_RDWR; kt_data_t *kt = t->t_data; const char *kvmfile; kvm_t *cookie; int mode; if (!iochg && !rwchg) return (0); if (iochg) { kvmfile = (flags & MDB_TGT_F_ALLOWIO) ? "/dev/allkmem" : "/dev/kmem"; } else { kvmfile = kt->k_kvmfile; } mode = (flags & MDB_TGT_F_RDWR) ? O_RDWR : O_RDONLY; if ((cookie = kvm_open(kt->k_symfile, kvmfile, NULL, mode, mdb.m_pname)) == NULL) { /* We failed to re-open, so don't change t_flags */ warn("failed to re-open target"); return (-1); } /* * We successfully reopened the target, so update k_kvmfile. Also set * the RDWR and ALLOWIO bits in t_flags to match those in flags. */ (void) kvm_close(kt->k_cookie); kt->k_cookie = cookie; if (kvmfile != kt->k_kvmfile) { strfree(kt->k_kvmfile); kt->k_kvmfile = strdup(kvmfile); } t->t_flags = (t->t_flags & ~(MDB_TGT_F_RDWR | MDB_TGT_F_ALLOWIO)) | (flags & (MDB_TGT_F_RDWR | MDB_TGT_F_ALLOWIO)); return (0); }
static void unmapClient( disruptor* d, unsigned int id ) { assert( id < MAX_CONNECTIONS ); if ( id >= MAX_CONNECTIONS ) return; { shmemClose( d->buffers[ id ].shmem ); d->buffers[ id ].shmem = NULL; d->buffers[ id ].start = NULL; d->buffers[ id ].tail = NULL; d->buffers[ id ].end = NULL; } strfree( d->names[ id ] ); d->names[ id ] = NULL; }
int notify_hints_type(ErlNifEnv *env, NotifyNotification *notify, int arity, ERL_NIF_TERM key, ERL_NIF_TERM value) { char a_key[256] = {0}; union { ErlNifBinary b; int i; double d; } val; const ERL_NIF_TERM *byte = NULL; char a_byte[256] = {0}; int len = 0; if (!enif_get_atom(env, key, a_key, sizeof(a_key), ERL_NIF_LATIN1)) return -1; if (enif_get_int(env, value, &val.i)) notify_notification_set_hint_int32(notify, a_key, val.i); else if (enif_get_double(env, value, &val.d)) notify_notification_set_hint_double(notify, a_key, val.d); else if (enif_get_tuple(env, value, &len, &byte)) { if (len != 2 || !enif_get_atom(env, byte[0], a_byte, sizeof(a_byte), ERL_NIF_LATIN1) || (strcmp(a_byte, "byte") != 0) || !enif_get_int(env, byte[1], &val.i)) return -1; notify_notification_set_hint_byte(notify, a_key, (u_int8_t)val.i); } else if (arity == 0 || enif_inspect_iolist_as_binary(env, value, &val.b)) { gchar *tmpstr = NULL; if (arity > 0) tmpstr = stralloc(&val.b); notify_notification_set_hint_string(notify, a_key, (arity > 0 ? "" : tmpstr)); strfree(tmpstr); } else return -1; return 0; }
/*============================ * browsescreen_init - initialize one browse screen * title is strsaved inside here * Can be called to reinitialize an existing browsescreen * Created: 2002/10/27, Perry Rapp *==========================*/ static void browsescreen_init (struct BrowseScreenInfo * sinfo , STRING title, INT MenuRows, INT MenuCols , INT MinCols, INT MaxCols , INT MinRows, INT MaxRows , INT MenuTop, INT MenuLeft, INT MenuWidth , INT MenuSize, MenuItem ** MenuItems) { DYNMENU dynmenu = &sinfo->dynmenu; strfree(&sinfo->title); sinfo->title = strsave(title); dynmenu_init(dynmenu, title, MenuRows, MenuCols , MinCols, MaxCols , MinRows, MaxRows , MenuTop, MenuLeft, MenuWidth , MenuSize, MenuItems); }
static void clear_opttable(Opttable *tab) { int i; if (tab == NULL || tab->optlist == NULL) return; for (i = 0; i < tab->optnum; i++) strfree(tab->optlist[i].name); free(tab->optlist); tab->optlist = NULL; tab->optlen = 0; tab->optnum = 0; tab->sorted = FALSE; }
static int __zpl_xattr_security_set(struct inode *ip, const char *name, const void *value, size_t size, int flags) { char *xattr_name; int error; /* xattr_resolve_name will do this for us if this is defined */ #ifndef HAVE_XATTR_HANDLER_NAME if (strcmp(name, "") == 0) return (-EINVAL); #endif xattr_name = kmem_asprintf("%s%s", XATTR_SECURITY_PREFIX, name); error = zpl_xattr_set(ip, xattr_name, value, size, flags); strfree(xattr_name); return (error); }
/*===========================================+ * llrpt_deletefromset -- Remove person from INDISEQ * usage: deletefromset(SET, INDI, BOOL) -> VOID *==========================================*/ PVALUE llrpt_deletefromset (PNODE node, SYMTAB stab, BOOLEAN *eflg) { NODE indi; STRING key=0; BOOLEAN all, rc; INDISEQ seq; PNODE arg1 = builtin_args(node), arg2 = inext(arg1), arg3 = inext(arg2); PVALUE val1 = eval_and_coerce(PSET, arg1, stab, eflg); PVALUE val3=0; if (*eflg) { prog_var_error(node, stab, arg1, val1, nonsetx, "deletefromset", "1"); goto dfs_exit; } ASSERT(seq = pvalue_to_seq(val1)); indi = eval_indi(arg2, stab, eflg, NULL); if (*eflg) { prog_var_error(node, stab, arg2, NULL, nonindx, "deletefromset", "2"); goto dfs_exit; } if (!indi) goto dfs_exit; *eflg = TRUE; if (!(key = strsave(rmvat(nxref(indi))))) { prog_error(node, "major error in deletefromset."); goto dfs_exit; } *eflg = FALSE; val3 = eval_and_coerce(PBOOL, arg3, stab, eflg); if (*eflg) { prog_var_error(node, stab, arg2, NULL, nonboox, "deletefromset", "3"); goto dfs_exit; } all = pvalue_to_bool(val3); delete_pvalue(val3); do { rc = delete_indiseq(seq, key, NULL, 0); } while (rc && all); dfs_exit: /* delay delete of val1 to last minute lest it is a temp owning seq, eg, deletefromset(ancestorset(i),j) */ if (val1) delete_pvalue(val1); if (key) strfree(&key); return NULL; }
/* Remove gag node from gag list by name. Formerly remove_gag */ void cmd_ungag(char *name) { Gag *p; int val = 0; if (*name == '#') { val = atoi(name + 1); p = gag_head; while (p && (p->indx != val)) { p = p->next; } } else { p = find_gag(name); } if (!p) { msg("-- Gag %s was not defined.", name); return; } /* Head of list ? */ if (!p->prev) { /* Not sole node */ if (p->next) { gag_head = p->next; gag_head->prev = (Gag *)NULL; } else { gag_head = (Gag *)NULL; gag_tail = (Gag *)NULL; } } else if (!p->next) { /* End of list */ gag_tail = p->prev; p->prev->next = (Gag *)NULL; } else { /* Middle of list */ p->prev->next = p->next; p->next->prev = p->prev; } msg("-- Gag %s removed.", name); strfree(p->name); free(p); gag_update_index(); }
/*--------------------------------------------------------------- Routine : create_new_tree_cb Purpose : Callback function to create new tree. Space is allocated to hold the tree ---------------------------------------------------------------*/ void create_new_tree_cb( TREE_PIC_FOREST *tree_pic_forest) { /* Destroy old tree and plant a new one */ replant_tree(tree_pic_forest->tree_pic->tree); TreePicSetSelectedItem(tree_pic_forest->tree_pic, NULL); TreePicSetSelectedItem(tree_pic_forest->global_tree_pic, NULL); /* Disassociate database */ if(tree_pic_forest->tree_pic->tree->database) { strfree( tree_pic_forest->tree_pic->tree->database ); tree_pic_forest->tree_pic->tree->database = NULL; } FTAFrameSetWindowTitle( tree_pic_forest->tree_pic ); } /* create_new_tree_cb */
static void doOneImage(const char * const name, unsigned int const imageDoneCount, FILE * const fileP, bool const allimages, bool const justCount, bool const wantComments, bool * const eofP) { struct pam pam; const char * comments; enum pm_check_code checkRetval; pam.comment_p = &comments; pnm_readpaminit(fileP, &pam, PAM_STRUCT_SIZE(comment_p)); if (!justCount) { if (allimages) printf("%s:\tImage %d:\t", name, imageDoneCount); else printf("%s:\t", name); dumpHeader(pam); if (wantComments) dumpComments(comments); } strfree(comments); pnm_checkpam(&pam, PM_CHECK_BASIC, &checkRetval); if (allimages) { tuple * tuplerow; unsigned int row; tuplerow = pnm_allocpamrow(&pam); for (row = 0; row < pam.height; ++row) pnm_readpamrow(&pam, tuplerow); pnm_freepamrow(tuplerow); pnm_nextimage(fileP, eofP); } }
/* * Rename a zfs_snapentry_t in the zfs_snapshots_by_name. The structure is * removed, renamed, and added back to the new correct location in the tree. */ static int zfsctl_snapshot_rename(char *old_snapname, char *new_snapname) { zfs_snapentry_t *se; ASSERT(RW_WRITE_HELD(&zfs_snapshot_lock)); se = zfsctl_snapshot_find_by_name(old_snapname); if (se == NULL) return (ENOENT); zfsctl_snapshot_remove(se); strfree(se->se_name); se->se_name = strdup(new_snapname); zfsctl_snapshot_add(se); zfsctl_snapshot_rele(se); return (0); }
static int __zpl_xattr_trusted_set(struct inode *ip, const char *name, const void *value, size_t size, int flags) { char *xattr_name; int error; if (!capable(CAP_SYS_ADMIN)) return -EACCES; if (strcmp(name, "") == 0) return -EINVAL; xattr_name = kmem_asprintf("%s%s", XATTR_TRUSTED_PREFIX, name); error = zpl_xattr_set(ip, xattr_name, value, size, flags); strfree(xattr_name); return (error); }
static int __zpl_xattr_user_set(struct inode *ip, const char *name, const void *value, size_t size, int flags) { char *xattr_name; int error; if (strcmp(name, "") == 0) return -EINVAL; if (!(ITOZSB(ip)->z_flags & ZSB_XATTR)) return -EOPNOTSUPP; xattr_name = kmem_asprintf("%s%s", XATTR_USER_PREFIX, name); error = zpl_xattr_set(ip, xattr_name, value, size, flags); strfree(xattr_name); return (error); }