int main(int argc,char **argv) { char *p; char *keyword, *value, buf[1024]; if (argc != 2) exit(1); (void) strcpy(buf,argv[1]); p=buf; while((keyword=mystrtok(p,":")) != (char *) NULL) { p=(char *) NULL; value=mystrtok(p,"|&"); if (value == (char *) NULL) { (void) fprintf(stderr,"parameter %s requires a value\n", keyword); exit(1); } (void) fprintf(stderr,"keyword=%s value=%s\n",keyword,value); } }
int main(int argc, char const *argv[]) { char delimeters[] = "?,|"; char str[] = "Oh hi! Please, split with ?, commas, pipes|and|nothing|else."; char *splitting; splitting = mystrtok(str, delimeters); while(splitting != NULL) { printf("%s\n", splitting);; splitting = mystrtok(NULL, delimeters); } printf("\n"); char *splitting2; splitting2 = strtok(str, delimeters); while(splitting2 != NULL) { printf("%s\n", splitting2);; splitting2 = strtok(NULL, delimeters); } return 0; }
static void update(char *query) { char *addr; char *status_text; char *cp = query; if ((addr = mystrtok(&cp, " \t\r\n")) == 0 || (status_text = mystrtok(&cp, " \t\r\n")) == 0) { msg_warn("bad request format"); return; } while (*cp && ISSPACE(*cp)) cp++; if (*cp == 0) { msg_warn("bad request format"); return; } switch (verify_clnt_update(query, atoi(status_text), cp)) { case VRFY_STAT_OK: vstream_printf("OK\n"); vstream_fflush(VSTREAM_OUT); break; case VRFY_STAT_BAD: msg_warn("bad request format"); break; case VRFY_STAT_FAIL: msg_warn("request failed"); break; } }
unsigned int findFileBlockInPath(char *fileName) { char * path; char * directoryName; int tokens,directoryEntryNumber; unsigned int directoryBlockNumber; directoryBlock directory; int tokenPosition = 2; fileName = getData(fileName); path = (char*)mallocFS(mystrlen(fileName)); path = getData(strcpy(fileName, path)); tokens= qtytoken(path, '/'); directoryName = getData(mystrtok(path, '/', tokenPosition)); directoryEntryNumber = 0; directoryBlockNumber = ROOTBLOCK; readsector(2, &directory); if (directoryName[0] == '\0') return directoryBlockNumber; while (tokenPosition <= tokens) { directoryEntryNumber = findFileInDirectory(directory, directoryName); if (directoryEntryNumber == -1) { return -1; } directoryBlockNumber = directory.entries[directoryEntryNumber].fileBlockStart; readsector(directoryBlockNumber, (char *)&directory); directoryName = getData(mystrtok(path, '/', tokenPosition + 1)); tokenPosition++; } return directoryBlockNumber; }
int get_auths(char **tokptr, unsigned int *rval, const char **err) { const char *tok = mystrtok(NULL, " \t\n", tokptr); int val = 0; while (tok) { if (strcmp(tok, "none") == 0) val |= (1 << IPMI_AUTHTYPE_NONE); else if (strcmp(tok, "md2") == 0) val |= (1 << IPMI_AUTHTYPE_MD2); else if (strcmp(tok, "md5") == 0) val |= (1 << IPMI_AUTHTYPE_MD5); else if (strcmp(tok, "straight") == 0) val |= (1 << IPMI_AUTHTYPE_STRAIGHT); else { *err = "Invalid authorization type, must be 'none', 'md2'," " 'md5', or 'straight'"; return -1; } tok = mystrtok(NULL, " \t\n", tokptr); } *rval = val; return 0; }
/** Function to break a line into a list of tokens. Delimiters are replaced by end-of-string characters ('\0'), and a list of pointers to thus created substrings is created. \param line (input) - a line to be tokenized, the line will be modified! \param token_list (output) - a resulting table containing pointers to tokens, or NULLs (the table will be initially nulled ) all the pointers schould point to addresses within the line \param siz (input) - size of the table \param delim (input) - delimiter character \return number of tokens on success, 0 if \param token_list is too small to contain all the tokens, or if line was empty. */ static int tokenize_line(char *line, char **token_list, size_t siz, char delim) { size_t i; char *tok; /* Erase the table */ for (i = 0; i < siz; i++) { token_list[i] = NULL; } /* Empty line passed? */ if (line == NULL) { return 0; } /* Reinitialize, find the first token */ i = 0; tok = mystrtok(line, delim); /* Line contains no delim */ if (tok == NULL) { return 0; } token_list[ i++ ] = tok; /* Find the remaining tokens */ while (i < siz) { tok = mystrtok(NULL, delim); /* If NULL, no more tokens left */ if (tok == NULL) { break; } /* Add token to the list */ token_list[ i++ ] = tok; } /* Any tokens left? */ if (i == siz) { return 0; } else { return i; } }
int main(void) { char str[100] = "he:kl;;fjgh:fjhg; fdfjg:gfklgj"; char *p; printf("%s\n", mystrtok(str, ";:")); while(p = mystrtok(NULL, ";:")); printf("%s\n", p); return 0; }
int main(int unused_argc, char **unused_argv) { VSTRING *buf = vstring_alloc(100); VSTRING *result = vstring_alloc(100); char *cp; char *name; char *value; HTABLE *table; int stat; while (!vstream_feof(VSTREAM_IN)) { table = htable_create(0); /* * Read a block of definitions, terminated with an empty line. */ while (vstring_get_nonl(buf, VSTREAM_IN) != VSTREAM_EOF) { vstream_printf("<< %s\n", vstring_str(buf)); vstream_fflush(VSTREAM_OUT); if (VSTRING_LEN(buf) == 0) break; cp = vstring_str(buf); name = mystrtok(&cp, " \t\r\n="); value = mystrtok(&cp, " \t\r\n="); htable_enter(table, name, value ? mystrdup(value) : 0); } /* * Read a block of patterns, terminated with an empty line or EOF. */ while (vstring_get_nonl(buf, VSTREAM_IN) != VSTREAM_EOF) { vstream_printf("<< %s\n", vstring_str(buf)); vstream_fflush(VSTREAM_OUT); if (VSTRING_LEN(buf) == 0) break; cp = vstring_str(buf); VSTRING_RESET(result); stat = mac_expand(result, vstring_str(buf), MAC_EXP_FLAG_NONE, (char *) 0, lookup, (char *) table); vstream_printf("stat=%d result=%s\n", stat, vstring_str(result)); vstream_fflush(VSTREAM_OUT); } htable_free(table, myfree); vstream_printf("\n"); } /* * Clean up. */ vstring_free(buf); vstring_free(result); exit(0); }
int main(void) { VSTRING *buf = vstring_alloc(100); SERVER_ACL *argv; int ret; int have_tty = isatty(0); char *bufp; char *cmd; char *value; const NAME_CODE acl_map[] = { SERVER_ACL_NAME_ERROR, SERVER_ACL_ACT_ERROR, SERVER_ACL_NAME_PERMIT, SERVER_ACL_ACT_PERMIT, SERVER_ACL_NAME_REJECT, SERVER_ACL_ACT_REJECT, SERVER_ACL_NAME_DUNNO, SERVER_ACL_ACT_DUNNO, 0, }; #define VAR_SERVER_ACL "server_acl" while (vstring_get_nonl(buf, VSTREAM_IN) != VSTREAM_EOF) { bufp = STR(buf); if (have_tty == 0) { vstream_printf("> %s\n", bufp); vstream_fflush(VSTREAM_OUT); } if (*bufp == '#') continue; if ((cmd = mystrtok(&bufp, " =")) == 0 || STREQ(cmd, "?")) { vstream_printf("usage: %s=value|%s=value|address=value\n", VAR_MYNETWORKS, VAR_SERVER_ACL); } else if ((value = mystrtok(&bufp, " =")) == 0) { vstream_printf("missing value\n"); } else if (STREQ(cmd, VAR_MYNETWORKS)) { UPDATE_VAR(var_mynetworks, value); } else if (STREQ(cmd, VAR_SERVER_ACL)) { UPDATE_VAR(var_server_acl, value); } else if (STREQ(cmd, "address")) { server_acl_pre_jail_init(var_mynetworks, VAR_SERVER_ACL); argv = server_acl_parse(var_server_acl, VAR_SERVER_ACL); ret = server_acl_eval(value, argv, VAR_SERVER_ACL); argv_free(argv); vstream_printf("%s: %s\n", value, str_name_code(acl_map, ret)); } else { vstream_printf("unknown command: \"%s\"\n", cmd); } vstream_fflush(VSTREAM_OUT); } vstring_free(buf); exit(0); }
int main(void) { char str[] = "degh,odf;j,oi"; const char delim[]=",;"; char *p; /*fgets(str,sizeof(str),stdin) str[strlen(str)] = '\0'; fgets(delim,sizeof(delim),stdin) str[strlen(delim)] = '\0';*/ printf("%s\n",mystrtok(str,delim)); while(p = mystrtok(NULL,delim)) //printf("%s\n",mystrtok(NULL,delim)); printf("%s\n",p); return 0; }
int get_bool(char **tokptr, unsigned int *rval, const char **err) { const char *tok = mystrtok(NULL, " \t\n", tokptr); if (!tok) { *err = "No boolean value given"; return -1; } if (strcasecmp(tok, "true") == 0) *rval = 1; else if (strcasecmp(tok, "false") == 0) *rval = 0; else if (strcasecmp(tok, "on") == 0) *rval = 1; else if (strcasecmp(tok, "off") == 0) *rval = 0; else if (strcasecmp(tok, "yes") == 0) *rval = 1; else if (strcasecmp(tok, "no") == 0) *rval = 0; else if (strcasecmp(tok, "1") == 0) *rval = 1; else if (strcasecmp(tok, "0") == 0) *rval = 0; else { *err = "Invalid boolean value, must be 'true', 'on', 'false', or 'off'"; return -1; } return 0; }
int set_atom_path(t_atom_path *p_ap, const char* str) { t_atom_path ap = *p_ap; char str_copy[maxchar]; strcpy(str_copy, str); char token[maxchar], remainder[maxchar]; strcpy(remainder, str); ap.length = 0; while(strlen(remainder)>0) { mystrtok(remainder, token, bond_delim); if(strlen(token)>5) { printf("Error: Atom identifier %s is too long (5 character is pdb maximum).\n", token); ap.length = 0; *p_ap = ap; return 0; } sscanf(token, "%s", ap.Path[ap.length]); ap.length++; if(ap.length==MAX_PATH_LENGTH) { printf("Error setting atom path. Path exceeds maximum length (%d bonds): %s\n", MAX_PATH_LENGTH, str); return 0; } } *p_ap = ap; return 1; }
int get_priv(char **tokptr, unsigned int *rval, const char **err) { const char *tok = mystrtok(NULL, " \t\n", tokptr); if (!tok) { *err = "No privilege specified, must be 'callback', 'user'," " 'operator', or 'admin'"; return -1; } if (strcmp(tok, "callback") == 0) *rval = IPMI_PRIVILEGE_CALLBACK; else if (strcmp(tok, "user") == 0) *rval = IPMI_PRIVILEGE_USER; else if (strcmp(tok, "operator") == 0) *rval = IPMI_PRIVILEGE_OPERATOR; else if (strcmp(tok, "admin") == 0) *rval = IPMI_PRIVILEGE_ADMIN; else { *err = "Invalid privilege specified, must be 'callback', 'user'," " 'operator', or 'admin'"; return -1; } return 0; }
char * getPathName(char * pathName, int type) { int lengthName = mystrlen(pathName); char *path = (char*)mallocFS(lengthName); int tokens = qtytoken(pathName, '/'); int tokenPosition = 2; int i = 0; char *dirName = (char*)mallocFS(lengthName); if (tokens == 1 && type == 1) { path[0] = pathName[0]; path[1] = '\0'; } if (tokens == 2) { path[0] = '/'; path = getData(path); } while (tokenPosition <= tokens - 1) { char *token = mystrtok(pathName, '/', tokenPosition); if (tokenPosition == 2) path = getData(mistrcat("/", token)); else path = getData(mistrcat(path, token)); if (tokenPosition < tokens - 1) { path = getData(path); path = mistrcat(path, "/"); path = getData(path); } tokenPosition++; } if (type == 1)//retorna path sin la ultima carpeta o archivo { return path; } else { dirName = mystrtok(pathName, '/', tokens); dirName = getData(dirName); return dirName; } }
long long_name_mask_delim_opt(const char *context, const LONG_NAME_MASK * table, const char *names, const char *delim, int flags) { const char *myname = "name_mask"; char *saved_names = mystrdup(names); char *bp = saved_names; long result = 0; const LONG_NAME_MASK *np; char *name; int (*lookup) (const char *, const char *); unsigned long ulval; if ((flags & NAME_MASK_REQUIRED) == 0) msg_panic("%s: missing NAME_MASK_FATAL/RETURN/WARN/IGNORE flag", myname); if (flags & NAME_MASK_ANY_CASE) lookup = strcasecmp; else lookup = strcmp; /* * Break up the names string, and look up each component in the table. If * the name is found, merge its mask with the result. */ while ((name = mystrtok(&bp, delim)) != 0) { for (np = table; /* void */ ; np++) { if (np->name == 0) { if ((flags & NAME_MASK_NUMBER) && hex_to_ulong(name, ~0UL, &ulval)) { result |= ulval; } else if (flags & NAME_MASK_FATAL) { msg_fatal("unknown %s value \"%s\" in \"%s\"", context, name, names); } else if (flags & NAME_MASK_RETURN) { msg_warn("unknown %s value \"%s\" in \"%s\"", context, name, names); myfree(saved_names); return (0); } else if (flags & NAME_MASK_WARN) { msg_warn("unknown %s value \"%s\" in \"%s\"", context, name, names); } break; } if (lookup(name, np->name) == 0) { if (msg_verbose) msg_info("%s: %s", myname, name); result |= np->mask; break; } } } myfree(saved_names); return (result); }
void register_dbms_parameters(const char *param_value, const char *(flag_parameter) (const char *, int, PC_MASTER_ENT *), PC_MASTER_ENT *local_scope) { const PC_DBMS_INFO *dp; char *bufp; char *db_type; char *prefix; static VSTRING *buffer = 0; static VSTRING *candidate = 0; const char **cpp; /* * XXX This does not examine both sides of conditional macro expansion, * and may expand the "wrong" conditional macros. This is the best we can * do for legacy database configuration support. */ if (buffer == 0) buffer = vstring_alloc(100); bufp = expand_parameter_value(buffer, SHOW_EVAL, param_value, local_scope); /* * Naive parsing. We don't really know if the parameter specifies free * text or a list of databases. */ while ((db_type = mystrtok(&bufp, " ,\t\r\n")) != 0) { /* * Skip over "proxy:" maptypes, to emulate the proxymap(8) server's * behavior when opening a local database configuration file. */ while ((prefix = split_at(db_type, ':')) != 0 && strcmp(db_type, DICT_TYPE_PROXY) == 0) db_type = prefix; /* * Look for database:prefix where the prefix is not a pathname and * the database is a known type. Synthesize candidate parameter names * from the user-defined prefix and from the database-defined suffix * list, and see if those parameters have a "name=value" entry in the * local or global namespace. */ if (prefix != 0 && *prefix != '/' && *prefix != '.') { for (dp = dbms_info; dp->db_type != 0; dp++) { if (strcmp(db_type, dp->db_type) == 0) { for (cpp = dp->db_suffixes; *cpp; cpp++) { vstring_sprintf(candidate ? candidate : (candidate = vstring_alloc(30)), "%s_%s", prefix, *cpp); flag_parameter(STR(candidate), PC_PARAM_FLAG_DBMS | PC_PARAM_FLAG_USER, local_scope); } break; } } } } }
static char* mystrtok_spc(char* str) { char* ret = mystrtok(str, " \t"); if (!ret) return NULL; if (*mystrtok_pos) for (; *mystrtok_pos && isspace(*mystrtok_pos); mystrtok_pos++); return ret; }
static const char *mail_version_worker(MAIL_VERSION *mp, char *cp) { char *major_field; char *minor_field; char *patch_field; /* * Program name. */ if ((mp->program = mystrtok(&cp, "-")) == 0) return ("no program name"); /* * Major, minor, patchlevel. If this is a stable release, then we ignore * text after the patchlevel, in case there are vendor extensions. */ if ((major_field = mystrtok(&cp, "-")) == 0) return ("missing major version"); if ((minor_field = split_at(major_field, '.')) == 0) return ("missing minor version"); if ((mp->major = mail_version_int(major_field)) < 0) return ("bad major version"); patch_field = split_at(minor_field, '.'); if ((mp->minor = mail_version_int(minor_field)) < 0) return ("bad minor version"); if (patch_field == 0) mp->patch = -1; else if ((mp->patch = mail_version_int(patch_field)) < 0) return ("bad patchlevel"); /* * Experimental release. If this is not a stable release, we take * everything to the end of the string. */ if (patch_field != 0) mp->snapshot = 0; else if ((mp->snapshot = mystrtok(&cp, "")) == 0) return ("missing snapshot field"); return (0); }
ARGV *argv_split_append(ARGV *argvp, const char *string, const char *delim) { char *saved_string = mystrdup(string); char *bp = saved_string; char *arg; while ((arg = mystrtok(&bp, delim)) != 0) argv_add(argvp, arg, (char *) 0); argv_terminate(argvp); myfree(saved_string); return (argvp); }
int main(int argc, char **argv) { VSTRING *inbuf = vstring_alloc(100); VSTRING *result = vstring_alloc(100); char *bufp; char *cmd; char *target; char *junk; mail_conf_read(); while (vstring_get_nonl(inbuf, VSTREAM_IN) != VSTREAM_EOF) { bufp = STR(inbuf); if (!isatty(0)) { vstream_printf("> %s\n", bufp); vstream_fflush(VSTREAM_OUT); } if (*bufp == '#') continue; if ((cmd = mystrtok(&bufp, " \t")) == 0) { vstream_printf("usage: file path|map maptype:mapname\n"); vstream_fflush(VSTREAM_OUT); continue; } target = mystrtok(&bufp, " \t"); junk = mystrtok(&bufp, " \t"); if (strcmp(cmd, "file") == 0 && target && !junk) { data_redirect_file(result, target); vstream_printf("%s -> %s\n", target, STR(result)); } else if (strcmp(cmd, "map") == 0 && target && !junk) { data_redirect_map(result, target); vstream_printf("%s -> %s\n", target, STR(result)); } else { vstream_printf("usage: file path|map maptype:mapname\n"); } vstream_fflush(VSTREAM_OUT); } vstring_free(inbuf); return (0); }
ARGV *match_service_init(const char *patterns) { const char *delim = " ,\t\r\n"; ARGV *list = argv_alloc(1); char *saved_patterns = mystrdup(patterns); char *bp = saved_patterns; const char *item; while ((item = mystrtok(&bp, delim)) != 0) argv_add(list, item, (char *) 0); argv_terminate(list); myfree(saved_patterns); return (list); }
static void post_jail_init(char *service_name, char **unused_argv) { const char *sep = ", \t\r\n"; char *saved_filter; char *bp; char *type_name; /* * Are we proxy writer? */ if (strcmp(service_name, MAIL_SERVICE_PROXYWRITE) == 0) proxy_writer = 1; else if (strcmp(service_name, MAIL_SERVICE_PROXYMAP) != 0) msg_fatal("service name must be one of %s or %s", MAIL_SERVICE_PROXYMAP, MAIL_SERVICE_PROXYMAP); /* * Pre-allocate buffers. */ request = vstring_alloc(10); request_map = vstring_alloc(10); request_key = vstring_alloc(10); request_value = vstring_alloc(10); map_type_name_flags = vstring_alloc(10); /* * Prepare the pre-approved list of proxied tables. */ saved_filter = bp = mystrdup(proxy_writer ? var_proxy_write_maps : var_proxy_read_maps); proxy_auth_maps = htable_create(13); while ((type_name = mystrtok(&bp, sep)) != 0) { if (strncmp(type_name, PROXY_COLON, PROXY_COLON_LEN)) continue; do { type_name += PROXY_COLON_LEN; } while (!strncmp(type_name, PROXY_COLON, PROXY_COLON_LEN)); if (strchr(type_name, ':') != 0 && htable_locate(proxy_auth_maps, type_name) == 0) (void) htable_enter(proxy_auth_maps, type_name, (char *) 0); } myfree(saved_filter); /* * Never, ever, get killed by a master signal, as that could corrupt a * persistent database when we're in the middle of an update. */ if (proxy_writer != 0) setsid(); }
static char *get_str_ent(char **bufp, char *name, char *def_val) { char *value; if ((value = mystrtok(bufp, master_blanks)) == 0) fatal_with_context("missing \"%s\" field", name); if (strcmp(value, "-") == 0) { if (def_val == 0) fatal_with_context("field \"%s\" has no default value", name); return (def_val); } else { return (value); } }
int read_bytes(char **tokptr, unsigned char *data, const char **err, unsigned int len) { const char *tok = mystrtok(NULL, " \t\n", tokptr); char *end; if (!tok) { *err = "Missing password or username"; return -1; } if (*tok == '"') { unsigned int end; /* Ascii PW */ tok++; end = strlen(tok) - 1; if (tok[end] != '"') { *err = "ASCII password or username doesn't end in '\"'"; return -1; } if (end > (len - 1)) end = len - 1; memcpy(data, tok, end); data[end] = '\0'; zero_extend_ascii(data, len); } else { unsigned int i; char c[3]; /* HEX pw */ if (strlen(tok) != 32) { *err = "HEX password or username not 32 HEX characters long"; return -1; } c[2] = '\0'; for (i=0; i<len; i++) { c[0] = *tok; tok++; c[1] = *tok; tok++; data[i] = strtoul(c, &end, 16); if (*end != '\0') { *err = "Invalid HEX character in password or username"; return -1; } } } return 0; }
static int load_tas(TLS_DANE *dane, const char *files) { int ret = 0; char *save = mystrdup(files); char *buf = save; char *file; do { if ((file = mystrtok(&buf, "\t\n\r ,")) != 0) ret = tls_dane_load_trustfile(dane, file); } while (file && ret); myfree(save); return (ret); }
MILTERS *milter_new(const char *names, int conn_timeout, int cmd_timeout, int msg_timeout, const char *protocol, const char *def_action, MILTER_MACROS *macros) { MILTERS *milters; MILTER *head = 0; MILTER *tail = 0; char *name; MILTER *milter; const char *sep = ", \t\r\n"; /* * Parse the milter list. */ milters = (MILTERS *) mymalloc(sizeof(*milters)); if (names != 0) { char *saved_names = mystrdup(names); char *cp = saved_names; while ((name = mystrtok(&cp, sep)) != 0) { milter = milter8_create(name, conn_timeout, cmd_timeout, msg_timeout, protocol, def_action, milters); if (head == 0) { head = milter; } else { tail->next = milter; } tail = milter; } myfree(saved_names); } milters->milter_list = head; milters->mac_lookup = 0; milters->mac_context = 0; milters->macros = macros; milters->add_header = 0; milters->upd_header = milters->ins_header = 0; milters->del_header = 0; milters->add_rcpt = milters->del_rcpt = 0; milters->repl_body = 0; milters->chg_context = 0; return (milters); }
int read_coupsites(FILE *fp, t_amide_map *p_map) { int i; int success = 0; // Number of map sites successfully allocated char line[maxchar]; t_amide_map map = *p_map; map.CoupSites = (t_coupsite*) malloc(map.ncoupsites*sizeof(t_coupsite)); if(map.CoupSites==NULL) { map.ncoupsites = 0; success = 0; } for(i=0; i<map.ncoupsites; i++) { if(fgets(line, maxchar, fp)!=NULL) { int natoms = count_tokens(line, path_delim); int error = 0; if(natoms>0) { map.CoupSites[i].AtomPaths = (t_atom_path*) malloc(natoms*sizeof(t_atom_path)); if(map.CoupSites[i].AtomPaths!=NULL) { map.CoupSites[i].natoms = natoms; char token[maxchar], remainder[maxchar]; int path = 0; strcpy(remainder, line); while(strlen(remainder)!=0) { mystrtok(remainder, token, path_delim); set_atom_path(&map.CoupSites[i].AtomPaths[path], token); path++; } } else error = 1; } else error = 1; if(error) { i = map.ncoupsites; break; } success++; } else return 0; } if(success<map.ncoupsites) { for(i=0; i<success; i++) { free(map.CoupSites[i].AtomPaths); } free(map.CoupSites); map.ncoupsites = 0; } *p_map = map; return 1; }
static char *get_str_ent(char **bufp, char *name, char *def_val) { char *value; if ((value = mystrtok(bufp, master_blanks)) == 0) fatal_with_context("missing \"%s\" field", name); if (strcmp(value, "-") == 0) { if (def_val == 0) fatal_with_context("field \"%s\" has no default value", name); if (warn_compat_break_chroot && strcmp(name, "chroot") == 0) msg_info("%s: using backwards-compatible default setting " "%s=%s", master_conf_context(), name, def_val); return (def_val); } else { return (value); } }
MAPS *maps_create(const char *title, const char *map_names, int dict_flags) { const char *myname = "maps_create"; char *temp; char *bufp; static char sep[] = " \t,\r\n"; MAPS *maps; char *map_type_name; VSTRING *map_type_name_flags; DICT *dict; /* * Initialize. */ maps = (MAPS *) mymalloc(sizeof(*maps)); maps->title = mystrdup(title); maps->argv = argv_alloc(2); /* * For each specified type:name pair, either register a new dictionary, * or increment the reference count of an existing one. */ if (*map_names) { bufp = temp = mystrdup(map_names); map_type_name_flags = vstring_alloc(10); #define OPEN_FLAGS O_RDONLY while ((map_type_name = mystrtok(&bufp, sep)) != 0) { vstring_sprintf(map_type_name_flags, "%s(%o,%s)", map_type_name, OPEN_FLAGS, dict_flags_str(dict_flags)); if ((dict = dict_handle(vstring_str(map_type_name_flags))) == 0) dict = dict_open(map_type_name, OPEN_FLAGS, dict_flags); if ((dict->flags & dict_flags) != dict_flags) msg_panic("%s: map %s has flags 0%o, want flags 0%o", myname, map_type_name, dict->flags, dict_flags); dict_register(vstring_str(map_type_name_flags), dict); argv_add(maps->argv, vstring_str(map_type_name_flags), ARGV_END); } myfree(temp); vstring_free(map_type_name_flags); } return (maps); }
int get_uchar(char **tokptr, unsigned char *rval, const char **err) { char *end; const char *tok = mystrtok(NULL, " \t\n", tokptr); if (!tok) { *err = "No integer value given"; return -1; } *rval = strtoul(tok, &end, 0); if (*end != '\0') { *err = "Invalid integer value"; return -1; } return 0; }