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);
}
