/* translates SELinux context from human to raw format and * appends it to the mount extra options. * * returns -1 on error and 0 on success */ static int append_context(const char *optname, char *optdata, char **extra_opts) { security_context_t raw = NULL; char *data = NULL; if (is_selinux_enabled() != 1) /* ignore the option if we running without selinux */ return 0; if (optdata == NULL || *optdata == '\0' || optname == NULL) return -1; /* TODO: use strip_quotes() for all mount options? */ data = *optdata == '"' ? strip_quotes(optdata) : optdata; if (selinux_trans_to_raw_context( (security_context_t) data, &raw) == -1 || raw == NULL) return -1; if (verbose) printf(_("%s: translated %s '%s' to '%s'\n"), progname, optname, data, (char *) raw); *extra_opts = append_opt(*extra_opts, optname, NULL); *extra_opts = xstrconcat4(*extra_opts, "\"", (char *) raw, "\""); freecon(raw); return 0; }
static Character const* __cdecl get_directory( Character const* const alternative, Character const** const result ) throw() { typedef __acrt_stdio_char_traits<Character> stdio_traits; __crt_unique_heap_ptr<Character const> tmp(get_tmp_directory<Character>()); if (tmp.get() != nullptr) { if (stdio_traits::taccess_s(tmp.get(), 0) == 0) return *result = tmp.detach(); // Otherwise, try stripping quotes out of the TMP path and check again: __crt_unique_heap_ptr<Character const> unquoted_tmp(strip_quotes(tmp.get())); if (unquoted_tmp.get() != nullptr && stdio_traits::taccess_s(unquoted_tmp.get(), 0) == 0) return *result = unquoted_tmp.detach(); } // Otherwise, the TMP path is not usable; use the alternative path if one // was provided and is accessible: if (alternative != nullptr && stdio_traits::taccess_s(alternative, 0) == 0) return (*result = alternative), nullptr; // Otherwise, fall back to \ or .: static Character const root_fallback[] = { '\\', '\0' }; static Character const cwd_fallback [] = { '.', '\0' }; if (stdio_traits::taccess_s(root_fallback, 0) == 0) return (*result = root_fallback), nullptr; return (*result = cwd_fallback), nullptr; }
static int _set_rec(int *start, int argc, char *argv[], slurmdb_job_rec_t *job) { int i; int set = 0; int end = 0; int command_len = 0; for (i=(*start); i<argc; i++) { end = parse_option_end(argv[i]); if (!end) command_len=strlen(argv[i]); else { command_len=end-1; if (argv[i][end] == '=') { end++; } } if (!strncasecmp (argv[i], "Where", MAX(command_len, 5))) { i--; break; } else if (!end && !strncasecmp(argv[i], "set", MAX(command_len, 3))) { continue; } else if (!end) { exit_code=1; fprintf(stderr, " Bad format on %s: End your option with " "an '=' sign\n", argv[i]); } else if ((!strncasecmp(argv[i], "DerivedExitCode", MAX(command_len, 12))) || (!strncasecmp(argv[i], "DerivedEC", MAX(command_len, 9)))) { if (get_uint(argv[i]+end, &job->derived_ec, "DerivedExitCode") == SLURM_SUCCESS) { set = 1; } } else if ((!strncasecmp(argv[i], "Comment", MAX(command_len, 7))) || (!strncasecmp(argv[i], "DerivedExitString", MAX(command_len, 12))) || (!strncasecmp(argv[i], "DerivedES", MAX(command_len, 9)))) { if (job->derived_es) xfree(job->derived_es); job->derived_es = strip_quotes(argv[i]+end, NULL, 1); set = 1; } else { printf(" Unknown option: %s\n" " Use keyword 'where' to modify condition\n", argv[i]); } } (*start) = i; return set; }
/* parses the destination directory parameters from pszSection * the parameters are of the form: root,key,value,unknown,fallback * we first read the reg value root\\key\\value and if that fails, * use fallback as the destination directory */ static void get_dest_dir(HINF hInf, PCWSTR pszSection, PWSTR pszBuffer, DWORD dwSize) { INFCONTEXT context; WCHAR key[MAX_PATH + 2], value[MAX_PATH + 2]; WCHAR prefix[PREFIX_LEN + 2]; HKEY root, subkey = 0; DWORD size; static const WCHAR hklm[] = {'H','K','L','M',0}; static const WCHAR hkcu[] = {'H','K','C','U',0}; /* load the destination parameters */ SetupFindFirstLineW(hInf, pszSection, NULL, &context); SetupGetStringFieldW(&context, 1, prefix, PREFIX_LEN + 2, &size); strip_quotes(prefix, &size); SetupGetStringFieldW(&context, 2, key, MAX_PATH + 2, &size); strip_quotes(key, &size); SetupGetStringFieldW(&context, 3, value, MAX_PATH + 2, &size); strip_quotes(value, &size); if (!lstrcmpW(prefix, hklm)) root = HKEY_LOCAL_MACHINE; else if (!lstrcmpW(prefix, hkcu)) root = HKEY_CURRENT_USER; else root = NULL; size = dwSize * sizeof(WCHAR); /* fallback to the default destination dir if reg fails */ if (RegOpenKeyW(root, key, &subkey) || RegQueryValueExW(subkey, value, NULL, NULL, (LPBYTE)pszBuffer, &size)) { SetupGetStringFieldW(&context, 5, pszBuffer, dwSize, &size); strip_quotes(pszBuffer, &size); } if (subkey) RegCloseKey(subkey); }
void hook_add(char *group, char *event, char *pattern, char *expr, int id) { log_msg("HOOK", "ADD"); log_msg("HOOK", "<%s> %s `%s`", event, pattern, expr); EventHandler *evh = get_event(event_idx(event)); if (!evh) return; expr = strip_quotes(expr); Pattern *pat = NULL; if (pattern) pat = regex_pat_new(pattern); Hook hook = { id, HK_CMD, NULL, NULL, NULL, pat, .data.cmd = expr }; augroup_insert(group, &hook); utarray_push_back(evh->hooks, &hook); } static void hook_delete(EventHandler *evh, Augroup *aug) { for (int i = 0; i < utarray_len(evh->hooks); i++) { Hook *it = (Hook*)utarray_eltptr(evh->hooks, i); if (it->type == HK_CMD && it->aug == aug) { free(it->data.cmd); utarray_erase(evh->hooks, i, 1); } } } void hook_remove(char *group, char *event, char *pattern) { log_msg("HOOK", "REMOVE"); log_msg("HOOK", "<%s> %s `%s`", event, pattern, group); Augroup *aug = NULL; if (group) HASH_FIND_STR(aug_tbl, group, aug); if (event) { EventHandler *evh = get_event(event_idx(event)); if (!evh) return; return hook_delete(evh, aug); } EventHandler *it; for (it = default_events; it != NULL; it = it->hh.next) hook_delete(it, aug); }
void PymolWriter::cleanup(std::string name, bool close) { if (close) { if (open_type_ != NONE) { get_stream() << "END,\n"; open_type_ = NONE; } if (lastname_ != placeholder_name) get_stream() << "]\n"; } lastname_ = placeholder_name; get_stream() << "k= '" << strip_quotes(name) << "'" << std::endl; get_stream() << "if k in data.keys():\n" << " data[k]= data[k]+curdata\nelse:\n" << " data[k]= curdata\n\n"; }
int conf_parse(const char *filename, int (*handler) (void *, const char *, const char *), void *usercfg) { FILE *fin; char buf[MAX_LINE]; char *start; char *end; char *name; char *value; int error = 0; fin = fopen(filename, "r"); if (!fin) return -1; int lineno = 0; /* Scan through file line by line */ while (fgets(buf, sizeof(buf), fin) != NULL) { lineno++; start = lskip(rstrip(buf)); /* chop whites */ if (*start && *start != '#') { /* Not a comment, must be a name = value pair */ end = find_char_or_comment(start, '='); if (*end == '=') { *end = '\0'; name = rstrip(start); value = lskip(end + 1); end = find_char_or_comment(value, '#'); if (*end == '#') *end = '\0'; value = rstrip(value); value = strip_quotes(value); /* Valid name=value pair found, call handler */ if (handler(usercfg, name, value) && !error) error = lineno; } else if (!error) { /* No '=' found on name=value line */ error = lineno; } } } fclose(fin); return error; }
static gn_error ReplyIdentify(int messagetype, unsigned char *buffer, int length, gn_data *data, struct gn_statemachine *state) { at_line_buffer buf; gn_error error; char *model; /* If we got incorrect answer, fallback to the default handler; * we got error handling in there. * strlen(buffer) < 2 is to avoid overflow with buffer + 1 */ if (strlen(buffer) < 2 || strncmp(buffer + 1, "AT+CGMM", 7) != 0) { return (*identify)(messagetype, buffer, length, data, state); } if ((error = at_error_get(buffer, state)) != GN_ERR_NONE) return error; buf.line1 = buffer + 1; buf.length = length; splitlines(&buf); /* The line usually looks like: * +CGMM: "GSM900","GSM1800","GSM1900","GSM850","MODEL=V547" */ model = strstr(buf.line2, "MODEL="); if (!model) { snprintf(data->model, GN_MODEL_MAX_LENGTH, "%s", strip_quotes(buf.line2 + 1 + strlen("+CGMM: "))); } else { snprintf(data->model, GN_MODEL_MAX_LENGTH, "%s", strip_quotes(model + strlen("MODEL="))); model = strchr(data->model, '"'); if (model) *model = '\0'; } return GN_ERR_NONE; }
void PymolWriter::setup(std::string name, Type type, bool opendata) { if (name == lastname_) { if (open_type_ != type && open_type_ != NONE) { get_stream() << "END,\n"; open_type_ = NONE; } return; } else if (lastname_ != placeholder_name) { cleanup(lastname_); } if (name.empty()) { name = "unnamed"; } get_stream() << "k= '" << strip_quotes(name) << "'\n"; get_stream() << "if not k in data.keys():\n" << " data[k]=[]\n"; if (opendata) get_stream() << "curdata=[\n"; lastname_ = name; }
/* * defread() - read an entry from the defopen file * * defread(cp) * char *cp * * The defopen data file must have been previously opened by * defopen(). defread scans the data file looking for a line * which begins with the string '*cp'. If such a line is found, * defread returns a pointer to the first character following * the matched string (*cp). If no line is found or no file * is open, defread() returns NULL. * * Note that there is no way to simulatniously peruse multiple * defopen files; since there is no way of indicating 'which one' * to defread(). If you want to peruse a secondary file you must * recall defopen(). If you need to go back to the first file, * you must call defopen() again. */ char * defread(char *cp) { struct thr_data *thr_data = _get_thr_data(); int (*compare)(const char *, const char *, size_t); char *buf_tmp, *ret_ptr = NULL; size_t off, patlen; if (thr_data == NULL) return (NULL); if (thr_data->fp == NULL) return (NULL); compare = TSTBITS(thr_data->Dcflags, DC_CASE) ? strncmp : strncasecmp; patlen = strlen(cp); if (!TSTBITS(thr_data->Dcflags, DC_NOREWIND)) rewind(thr_data->fp); while (fgets(thr_data->buf, sizeof (thr_data->buf), thr_data->fp)) { for (buf_tmp = thr_data->buf; *buf_tmp == ' '; buf_tmp++) ; off = strlen(buf_tmp) - 1; if (buf_tmp[off] == '\n') buf_tmp[off] = 0; else break; /* line too long */ if ((*compare)(cp, buf_tmp, patlen) == 0) { /* found it */ /* strip quotes if requested */ if (TSTBITS(thr_data->Dcflags, DC_STRIP_QUOTES)) { strip_quotes(buf_tmp); } ret_ptr = &buf_tmp[patlen]; break; } } return (ret_ptr); }
extern int get_uint(char *in_value, uint32_t *out_value, char *type) { char *ptr = NULL, *meat = NULL; long num; if (!(meat = strip_quotes(in_value, NULL))) { error("Problem with strip_quotes"); return SLURM_ERROR; } num = strtol(meat, &ptr, 10); if ((num == 0) && ptr && ptr[0]) { error("Invalid value for %s (%s)", type, meat); xfree(meat); return SLURM_ERROR; } xfree(meat); if (num < 0) *out_value = INFINITE; /* flag to clear */ else *out_value = (uint32_t) num; return SLURM_SUCCESS; }
extern int sacctmgr_archive_load(int argc, char *argv[]) { int rc = SLURM_SUCCESS; slurmdb_archive_rec_t *arch_rec = xmalloc(sizeof(slurmdb_archive_rec_t)); int i=0, command_len = 0; struct stat st; for (i=0; i<argc; i++) { int end = parse_option_end(argv[i]); if (!end) command_len=strlen(argv[i]); else { command_len=end-1; if (argv[i][end] == '=') { end++; } } if (!end || !strncasecmp (argv[i], "File", MAX(command_len, 1))) { arch_rec->archive_file = strip_quotes(argv[i]+end, NULL, 0); } else if (!strncasecmp (argv[i], "Insert", MAX(command_len, 2))) { arch_rec->insert = strip_quotes(argv[i]+end, NULL, 1); } else { exit_code=1; fprintf(stderr, " Unknown option: %s\n", argv[i]); } } if (exit_code) { slurmdb_destroy_archive_rec(arch_rec); return SLURM_ERROR; } if (arch_rec->archive_file) { char *fullpath; char cwd[MAXPATHLEN + 1]; int mode = F_OK; if ((getcwd(cwd, MAXPATHLEN)) == NULL) fatal("getcwd failed: %m"); if ((fullpath = search_path(cwd, arch_rec->archive_file, true, mode, false))) { xfree(arch_rec->archive_file); arch_rec->archive_file = fullpath; } if (stat(arch_rec->archive_file, &st) < 0) { exit_code = errno; fprintf(stderr, " load: Failed to stat %s: %s\n " "Note: For archive load, the file must be on " "the calling host.\n", arch_rec->archive_file, slurm_strerror(errno)); return SLURM_ERROR; } } rc = jobacct_storage_g_archive_load(db_conn, arch_rec); if (rc == SLURM_SUCCESS) { if (commit_check("Would you like to commit changes?")) { acct_storage_g_commit(db_conn, 1); } else { printf(" Changes Discarded\n"); acct_storage_g_commit(db_conn, 0); } } else { exit_code=1; fprintf(stderr, " Problem loading archive file: %s\n", slurm_strerror(rc)); rc = SLURM_ERROR; } slurmdb_destroy_archive_rec(arch_rec); return rc; }
static int _set_cond(int *start, int argc, char *argv[], slurmdb_archive_cond_t *arch_cond) { int i; int set = 0; int end = 0; int command_len = 0; uint32_t tmp; slurmdb_job_cond_t *job_cond = NULL; if (!arch_cond) { error("No arch_cond given"); return -1; } if (!arch_cond->job_cond) arch_cond->job_cond = xmalloc(sizeof(slurmdb_job_cond_t)); job_cond = arch_cond->job_cond; for (i=(*start); i<argc; i++) { end = parse_option_end(argv[i]); if (!end) command_len=strlen(argv[i]); else { command_len=end-1; if (argv[i][end] == '=') { end++; } } if (!end && !strncasecmp(argv[i], "where", MAX(command_len, 5))) { continue; } else if (!end && !strncasecmp(argv[i], "events", MAX(command_len, 1))) { arch_cond->purge_event |= SLURMDB_PURGE_ARCHIVE; set = 1; } else if (!end && !strncasecmp(argv[i], "jobs", MAX(command_len, 1))) { arch_cond->purge_job |= SLURMDB_PURGE_ARCHIVE; set = 1; } else if (!end && !strncasecmp(argv[i], "reservations", MAX(command_len, 1))) { arch_cond->purge_resv |= SLURMDB_PURGE_ARCHIVE; set = 1; } else if (!end && !strncasecmp(argv[i], "steps", MAX(command_len, 1))) { arch_cond->purge_step |= SLURMDB_PURGE_ARCHIVE; set = 1; } else if (!end && !strncasecmp(argv[i], "suspend", MAX(command_len, 1))) { arch_cond->purge_suspend |= SLURMDB_PURGE_ARCHIVE; set = 1; } else if (!end || !strncasecmp(argv[i], "Clusters", MAX(command_len, 1))) { if (!job_cond->cluster_list) job_cond->cluster_list = list_create(slurm_destroy_char); slurm_addto_char_list(job_cond->cluster_list, argv[i]+end); set = 1; } else if (!strncasecmp (argv[i], "Accounts", MAX(command_len, 2))) { if (!job_cond->acct_list) job_cond->acct_list = list_create(slurm_destroy_char); slurm_addto_char_list(job_cond->acct_list, argv[i]+end); set = 1; } else if (!strncasecmp (argv[i], "Associations", MAX(command_len, 2))) { if (!job_cond->associd_list) job_cond->associd_list = list_create(slurm_destroy_char); slurm_addto_char_list(job_cond->associd_list, argv[i]+end); set = 1; } else if (!strncasecmp (argv[i], "Directory", MAX(command_len, 2))) { arch_cond->archive_dir = strip_quotes(argv[i]+end, NULL, 0); set = 1; } else if (!strncasecmp (argv[i], "End", MAX(command_len, 1))) { job_cond->usage_end = parse_time(argv[i]+end, 1); set = 1; } else if (!strncasecmp (argv[i], "Gid", MAX(command_len, 2))) { if (!job_cond->groupid_list) job_cond->groupid_list = list_create(slurm_destroy_char); slurm_addto_char_list(job_cond->groupid_list, argv[i]+end); set = 1; } else if (!strncasecmp (argv[i], "Jobs", MAX(command_len, 1))) { char *end_char = NULL, *start_char = argv[i]+end; slurmdb_selected_step_t *selected_step = NULL; char *dot = NULL; if (!job_cond->step_list) job_cond->step_list = list_create(slurm_destroy_char); while ((end_char = strstr(start_char, ",")) && start_char) { *end_char = 0; while (isspace(*start_char)) start_char++; /* discard whitespace */ if (!(int)*start_char) continue; selected_step = xmalloc( sizeof(slurmdb_selected_step_t)); list_append(job_cond->step_list, selected_step); dot = strstr(start_char, "."); if (dot == NULL) { debug2("No jobstep requested"); selected_step->stepid = NO_VAL; } else { *dot++ = 0; selected_step->stepid = atoi(dot); } selected_step->jobid = atoi(start_char); start_char = end_char + 1; } set = 1; } else if (!strncasecmp (argv[i], "Partitions", MAX(command_len, 2))) { if (!job_cond->partition_list) job_cond->partition_list = list_create(slurm_destroy_char); slurm_addto_char_list(job_cond->partition_list, argv[i]+end); set = 1; } else if (!strncasecmp (argv[i], "PurgeEventAfter", MAX(command_len, 10))) { if ((tmp = slurmdb_parse_purge(argv[i]+end)) == NO_VAL) { exit_code = 1; } else { arch_cond->purge_event |= tmp; set = 1; } } else if (!strncasecmp (argv[i], "PurgeJobAfter", MAX(command_len, 10))) { if ((tmp = slurmdb_parse_purge(argv[i]+end)) == NO_VAL) { exit_code = 1; } else { arch_cond->purge_job |= tmp; set = 1; } } else if (!strncasecmp (argv[i], "PurgeResvAfter", MAX(command_len, 10))) { if ((tmp = slurmdb_parse_purge(argv[i]+end)) == NO_VAL) { exit_code = 1; } else { arch_cond->purge_resv |= tmp; set = 1; } } else if (!strncasecmp (argv[i], "PurgeStepAfter", MAX(command_len, 10))) { if ((tmp = slurmdb_parse_purge(argv[i]+end)) == NO_VAL) { exit_code = 1; } else { arch_cond->purge_step |= tmp; set = 1; } } else if (!strncasecmp (argv[i], "PurgeSuspendAfter", MAX(command_len, 10))) { if ((tmp = slurmdb_parse_purge(argv[i]+end)) == NO_VAL) { exit_code = 1; } else { arch_cond->purge_suspend |= tmp; set = 1; } } else if (!strncasecmp (argv[i], "PurgeEventMonths", MAX(command_len, 6))) { if (get_uint(argv[i]+end, &tmp, "PurgeEventMonths") != SLURM_SUCCESS) { exit_code = 1; } else { arch_cond->purge_event |= tmp; arch_cond->purge_event |= SLURMDB_PURGE_MONTHS; set = 1; } } else if (!strncasecmp (argv[i], "PurgeJobMonths", MAX(command_len, 6))) { if (get_uint(argv[i]+end, &tmp, "PurgeJobMonths") != SLURM_SUCCESS) { exit_code = 1; } else { arch_cond->purge_job |= tmp; arch_cond->purge_job |= SLURMDB_PURGE_MONTHS; set = 1; } } else if (!strncasecmp (argv[i], "PurgeResvMonths", MAX(command_len, 6))) { if (get_uint(argv[i]+end, &tmp, "PurgeResvMonths") != SLURM_SUCCESS) { exit_code = 1; } else { arch_cond->purge_resv |= tmp; arch_cond->purge_resv |= SLURMDB_PURGE_MONTHS; set = 1; } } else if (!strncasecmp (argv[i], "PurgeStepMonths", MAX(command_len, 7))) { if (get_uint(argv[i]+end, &tmp, "PurgeStepMonths") != SLURM_SUCCESS) { exit_code = 1; } else { arch_cond->purge_step |= tmp; arch_cond->purge_step |= SLURMDB_PURGE_MONTHS; set = 1; } } else if (!strncasecmp (argv[i], "PurgeSuspendMonths", MAX(command_len, 7))) { if (get_uint(argv[i]+end, &tmp, "PurgeSuspendMonths") != SLURM_SUCCESS) { exit_code = 1; } else { arch_cond->purge_suspend |= tmp; arch_cond->purge_suspend |= SLURMDB_PURGE_MONTHS; set = 1; } } else if (!strncasecmp (argv[i], "Start", MAX(command_len, 2))) { job_cond->usage_start = parse_time(argv[i]+end, 1); set = 1; } else if (!strncasecmp (argv[i], "Script", MAX(command_len, 2))) { arch_cond->archive_script = strip_quotes(argv[i]+end, NULL, 0); set = 1; } else if (!strncasecmp (argv[i], "Users", MAX(command_len, 1))) { if (!job_cond->userid_list) job_cond->userid_list = list_create(slurm_destroy_char); _addto_uid_char_list(job_cond->userid_list, argv[i]+end); set = 1; } else { exit_code=1; fprintf(stderr, " Unknown condition: %s\n", argv[i]); } } (*start) = i; return set; }
void SimpleJsonParser::parse( std::vector<CString>& tokens ) { enum ParseState { SCAN=1, ARRAY, PAIR, PAIR_COLON, RVALUE, RVALUE_SEPARATOR }; ParseState state = SCAN; LPCSTR tag_name = NULL; CString array_index; std::stack<JsonNode *> nodeStack; m_values.clear(); m_type = JSONROOT; nodeStack.push( this ); for ( CString& token : tokens ) { // printf( "%s ", (LPCSTR)token ); switch ( state ) { case SCAN: if ( token == "[" ) { // Start of array m_type = JSONARRAY; state = RVALUE; break; } else if ( token == "{" ) { // Start of object m_type = JSONOBJECT; state = PAIR; break; } throw std::exception( "Parser expected opening object or array" ); case PAIR: // Check for empty object if ( token == "}" && nodeStack.top()->m_type == JSONOBJECT && nodeStack.top()->m_values.size() == 0 ) { nodeStack.pop(); state = RVALUE_SEPARATOR; break; } tag_name = strip_quotes( token ); state = PAIR_COLON; break; case PAIR_COLON: if ( token != ":" ) throw std::exception( "Parser expecting colon seperator" ); state = RVALUE; break; case RVALUE: { if ( token == "]" ) { // Empty array if ( nodeStack.top()->m_type != JSONARRAY ) throw std::exception( "Unexpected array closing bracket" ); nodeStack.pop(); state = RVALUE_SEPARATOR; break; } JsonNode* node = nodeStack.top(); if ( node->m_type == JSONARRAY ) { array_index.Format( "%d", node->m_values.size() ); tag_name = (LPCSTR)array_index; } if ( node->m_values.find( tag_name ) != node->m_values.end() ) { CString error; error.Format( "Duplicate JSON tag name '%s'", tag_name ); throw std::exception( (LPCSTR)error ); } if ( token == "[" ) { node->m_values[ tag_name ] = JsonNode( JSONARRAY ); state = RVALUE; nodeStack.push( &node->m_values[ tag_name ] ); break; } if ( token == "{" ) { node->m_values[ tag_name ] = JsonNode( JSONOBJECT ); state = PAIR; nodeStack.push( &node->m_values[ tag_name ] ); break; } // Add a constant to current node container if ( node->m_type != JSONOBJECT && node->m_type != JSONARRAY) throw std::exception( "Parser expecting container JSON node" ); node->m_values[ tag_name ] = JsonNode( strip_quotes( token ) ); state = RVALUE_SEPARATOR; break; } case RVALUE_SEPARATOR: { JsonNode* node = nodeStack.top(); if ( token == "," ) { state = node->m_type == JSONARRAY ? RVALUE : PAIR; break; } if ( token == "}" && node->m_type == JSONOBJECT ) { nodeStack.pop(); break; } if ( token == "]" && node->m_type == JSONARRAY ) { // Assert all non-null nodes in the array are the same type JsonNodeType expected_type = JSONNULL; for ( auto child : node->m_values ) { if ( child.second.m_type == JSONNULL ) ; else if ( expected_type == JSONNULL ) expected_type = child.second.m_type; else if ( child.second.m_type != expected_type ) { CString error; error.Format( "Mixed object types in '%s'", child.first ); throw std::exception( (LPCSTR)error ); } } nodeStack.pop(); break; } throw std::exception( "Parser expecting object or array seperator" ); } } } if ( nodeStack.size() > 0 ) throw std::exception( "Unclosed JSON objects detected" ); }
static int _set_res_rec(int *start, int argc, char *argv[], List name_list, List cluster_list, slurmdb_res_rec_t *res) { int i; int set = 0; int end = 0; int command_len = 0; int option = 0; xassert(res); for (i=(*start); i<argc; i++) { end = parse_option_end(argv[i]); if (!end) command_len=strlen(argv[i]); else { command_len=end-1; if (argv[i][end] == '=') { option = (int)argv[i][end-1]; end++; } } if (!strncasecmp(argv[i], "Where", MAX(command_len, 5))) { i--; break; } else if (!end && !strncasecmp(argv[i], "set", MAX(command_len, 3))) { continue; } else if (!end || !strncasecmp(argv[i], "Names", MAX(command_len, 1)) || !strncasecmp(argv[i], "Resources", MAX(command_len, 1))) { if (name_list) slurm_addto_char_list(name_list, argv[i]+end); } else if (!strncasecmp(argv[i], "Clusters", MAX(command_len, 1))) { if (cluster_list) { slurm_addto_char_list(cluster_list, argv[i]+end); if (sacctmgr_validate_cluster_list( cluster_list) != SLURM_SUCCESS) { exit_code=1; fprintf(stderr, " Need a valid cluster name to " "add a cluster resource.\n"); } } else { exit_code=1; fprintf(stderr, " Can't modify the cluster " "of an resource\n"); } } else if (!strncasecmp(argv[i], "Count", MAX(command_len, 3))) { if (get_uint(argv[i]+end, &res->count, "count") == SLURM_SUCCESS) { set = 1; } } else if (!strncasecmp(argv[i], "Description", MAX(command_len, 1))) { if (!res->description) res->description = strip_quotes(argv[i]+end, NULL, 1); set = 1; } else if (!strncasecmp(argv[i], "Flags", MAX(command_len, 2))) { res->flags = str_2_res_flags(argv[i]+end, option); if (res->flags == SLURMDB_RES_FLAG_NOTSET) { char *tmp_char = slurmdb_res_flags_str( SLURMDB_RES_FLAG_BASE); printf(" Unknown Server Resource flag used " "in:\n '%s'\n" " Valid Server Resource flags are\n" " '%s'\n", argv[i]+end, tmp_char); xfree(tmp_char); exit_code = 1; } else set = 1; } else if (!strncasecmp(argv[i], "Manager", MAX(command_len, 1))) { if (!res->manager) res->manager = strip_quotes(argv[i]+end, NULL, 1); set = 1; } else if (!strncasecmp(argv[i], "PercentAllowed", MAX(command_len, 1))) { /* overload percent_used here */ if (get_uint16(argv[i]+end, &res->percent_used, "PercentAllowed") == SLURM_SUCCESS) { set = 1; } } else if (!strncasecmp(argv[i], "Server", MAX(command_len, 1))) { if (!res->server) { res->server= strip_quotes(argv[i]+end, NULL, 1); } set = 1; } else if (!strncasecmp(argv[i], "Type", MAX(command_len, 1))) { char *temp = strip_quotes(argv[i]+end, NULL, 1); if (!strncasecmp("License", temp, MAX(strlen(temp), 1))) { res->type = SLURMDB_RESOURCE_LICENSE; } else { exit_code=1; fprintf(stderr, " Unknown resource type: '%s' " "Valid resources is License.\n", temp); } } else { exit_code = 1; printf(" Unknown option: %s\n" " Use keyword 'where' to modify condition\n", argv[i]); } } (*start) = i; return set; }
/* * parse_slash_copy parses copy options from the given meta-command line. The * function then returns a dynamically allocated structure with the options, or * Null on parsing error. */ copy_options * parse_slash_copy(const char *args) { struct copy_options *result; char *token; const char *whitespace = " \t\n\r"; char nonstd_backslash = standard_strings() ? 0 : '\\'; if (!args) { psql_error("\\copy: arguments required\n"); return NULL; } result = pg_malloc0(sizeof(struct copy_options)); result->before_tofrom = pg_strdup(""); /* initialize for appending */ token = strtokx(args, whitespace, ".,()", "\"", 0, false, false, pset.encoding); if (!token) goto error; /* The following can be removed when we drop 7.3 syntax support */ if (pg_strcasecmp(token, "binary") == 0) { xstrcat(&result->before_tofrom, token); token = strtokx(NULL, whitespace, ".,()", "\"", 0, false, false, pset.encoding); if (!token) goto error; } /* Handle COPY (SELECT) case */ if (token[0] == '(') { int parens = 1; while (parens > 0) { xstrcat(&result->before_tofrom, " "); xstrcat(&result->before_tofrom, token); token = strtokx(NULL, whitespace, "()", "\"'", nonstd_backslash, true, false, pset.encoding); if (!token) goto error; if (token[0] == '(') parens++; else if (token[0] == ')') parens--; } } xstrcat(&result->before_tofrom, " "); xstrcat(&result->before_tofrom, token); token = strtokx(NULL, whitespace, ".,()", "\"", 0, false, false, pset.encoding); if (!token) goto error; /* * strtokx() will not have returned a multi-character token starting with * '.', so we don't need strcmp() here. Likewise for '(', etc, below. */ if (token[0] == '.') { /* handle schema . table */ xstrcat(&result->before_tofrom, token); token = strtokx(NULL, whitespace, ".,()", "\"", 0, false, false, pset.encoding); if (!token) goto error; xstrcat(&result->before_tofrom, token); token = strtokx(NULL, whitespace, ".,()", "\"", 0, false, false, pset.encoding); if (!token) goto error; } if (token[0] == '(') { /* handle parenthesized column list */ for (;;) { xstrcat(&result->before_tofrom, " "); xstrcat(&result->before_tofrom, token); token = strtokx(NULL, whitespace, "()", "\"", 0, false, false, pset.encoding); if (!token) goto error; if (token[0] == ')') break; } xstrcat(&result->before_tofrom, " "); xstrcat(&result->before_tofrom, token); token = strtokx(NULL, whitespace, ".,()", "\"", 0, false, false, pset.encoding); if (!token) goto error; } if (pg_strcasecmp(token, "from") == 0) result->from = true; else if (pg_strcasecmp(token, "to") == 0) result->from = false; else goto error; /* { 'filename' | PROGRAM 'command' | STDIN | STDOUT | PSTDIN | PSTDOUT } */ token = strtokx(NULL, whitespace, ";", "'", 0, false, false, pset.encoding); if (!token) goto error; if (pg_strcasecmp(token, "program") == 0) { int toklen; token = strtokx(NULL, whitespace, ";", "'", 0, false, false, pset.encoding); if (!token) goto error; /* * The shell command must be quoted. This isn't fool-proof, but * catches most quoting errors. */ toklen = strlen(token); if (token[0] != '\'' || toklen < 2 || token[toklen - 1] != '\'') goto error; strip_quotes(token, '\'', 0, pset.encoding); result->program = true; result->file = pg_strdup(token); } else if (pg_strcasecmp(token, "stdin") == 0 || pg_strcasecmp(token, "stdout") == 0) { result->file = NULL; } else if (pg_strcasecmp(token, "pstdin") == 0 || pg_strcasecmp(token, "pstdout") == 0) { result->psql_inout = true; result->file = NULL; } else { /* filename can be optionally quoted */ strip_quotes(token, '\'', 0, pset.encoding); result->file = pg_strdup(token); expand_tilde(&result->file); } /* Collect the rest of the line (COPY options) */ token = strtokx(NULL, "", NULL, NULL, 0, false, false, pset.encoding); if (token) result->after_tofrom = pg_strdup(token); /* set data staging options to null */ result->tableName = NULL; result->columnList = NULL; return result; error: if (token) psql_error("\\copy: parse error at \"%s\"\n", token); else psql_error("\\copy: parse error at end of line\n"); free_copy_options(result); return NULL; }
/* * Replacement for strtok() (a.k.a. poor man's flex) * * Splits a string into tokens, returning one token per call, then NULL * when no more tokens exist in the given string. * * The calling convention is similar to that of strtok, but with more * frammishes. * * s - string to parse, if NULL continue parsing the last string * whitespace - set of whitespace characters that separate tokens * delim - set of non-whitespace separator characters (or NULL) * quote - set of characters that can quote a token (NULL if none) * escape - character that can quote quotes (0 if none) * e_strings - if TRUE, treat E'...' syntax as a valid token * del_quotes - if TRUE, strip quotes from the returned token, else return * it exactly as found in the string * encoding - the active character-set encoding * * Characters in 'delim', if any, will be returned as single-character * tokens unless part of a quoted token. * * Double occurrences of the quoting character are always taken to represent * a single quote character in the data. If escape isn't 0, then escape * followed by anything (except \0) is a data character too. * * The combination of e_strings and del_quotes both TRUE is not currently * handled. This could be fixed but it's not needed anywhere at the moment. * * Note that the string s is _not_ overwritten in this implementation. * * NB: it's okay to vary delim, quote, and escape from one call to the * next on a single source string, but changing whitespace is a bad idea * since you might lose data. */ char * strtokx(const char *s, const char *whitespace, const char *delim, const char *quote, char escape, bool e_strings, bool del_quotes, int encoding) { static char *storage = NULL;/* store the local copy of the users string * here */ static char *string = NULL; /* pointer into storage where to continue on * next call */ /* variously abused variables: */ unsigned int offset; char *start; char *p; if (s) { free(storage); /* * We may need extra space to insert delimiter nulls for adjacent * tokens. 2X the space is a gross overestimate, but it's unlikely * that this code will be used on huge strings anyway. */ storage = pg_malloc(2 * strlen(s) + 1); strcpy(storage, s); string = storage; } if (!storage) return NULL; /* skip leading whitespace */ offset = strspn(string, whitespace); start = &string[offset]; /* end of string reached? */ if (*start == '\0') { /* technically we don't need to free here, but we're nice */ free(storage); storage = NULL; string = NULL; return NULL; } /* test if delimiter character */ if (delim && strchr(delim, *start)) { /* * If not at end of string, we need to insert a null to terminate the * returned token. We can just overwrite the next character if it * happens to be in the whitespace set ... otherwise move over the * rest of the string to make room. (This is why we allocated extra * space above). */ p = start + 1; if (*p != '\0') { if (!strchr(whitespace, *p)) memmove(p + 1, p, strlen(p) + 1); *p = '\0'; string = p + 1; } else { /* at end of string, so no extra work */ string = p; } return start; } /* check for E string */ p = start; if (e_strings && (*p == 'E' || *p == 'e') && p[1] == '\'') { quote = "'"; escape = '\\'; /* if std strings before, not any more */ p++; } /* test if quoting character */ if (quote && strchr(quote, *p)) { /* okay, we have a quoted token, now scan for the closer */ char thisquote = *p++; for (; *p; p += PQmblen(p, encoding)) { if (*p == escape && p[1] != '\0') p++; /* process escaped anything */ else if (*p == thisquote && p[1] == thisquote) p++; /* process doubled quote */ else if (*p == thisquote) { p++; /* skip trailing quote */ break; } } /* * If not at end of string, we need to insert a null to terminate the * returned token. See notes above. */ if (*p != '\0') { if (!strchr(whitespace, *p)) memmove(p + 1, p, strlen(p) + 1); *p = '\0'; string = p + 1; } else { /* at end of string, so no extra work */ string = p; } /* Clean up the token if caller wants that */ if (del_quotes) strip_quotes(start, thisquote, escape, encoding); return start; } /* * Otherwise no quoting character. Scan till next whitespace, delimiter * or quote. NB: at this point, *start is known not to be '\0', * whitespace, delim, or quote, so we will consume at least one character. */ offset = strcspn(start, whitespace); if (delim) { unsigned int offset2 = strcspn(start, delim); if (offset > offset2) offset = offset2; } if (quote) { unsigned int offset2 = strcspn(start, quote); if (offset > offset2) offset = offset2; } p = start + offset; /* * If not at end of string, we need to insert a null to terminate the * returned token. See notes above. */ if (*p != '\0') { if (!strchr(whitespace, *p)) memmove(p + 1, p, strlen(p) + 1); *p = '\0'; string = p + 1; } else { /* at end of string, so no extra work */ string = p; } return start; }
static int _set_cond(int *start, int argc, char *argv[], slurmdb_reservation_cond_t *reservation_cond, List format_list) { int i; int set = 0; int end = 0; int command_len = 0; if (!reservation_cond) { exit_code=1; fprintf(stderr, "No reservation_cond given"); return -1; } for (i=(*start); i<argc; i++) { end = parse_option_end(argv[i]); if (!end) command_len=strlen(argv[i]); else { command_len=end-1; if (argv[i][end] == '=') { end++; } } if (!strncasecmp(argv[i], "Set", MAX(command_len, 3))) { i--; break; } else if (!end && !strncasecmp(argv[i], "where", MAX(command_len, 5))) { continue; } else if (!strncasecmp(argv[i], "Clusters", MAX(command_len, 1))) { if (!reservation_cond->cluster_list) { reservation_cond->cluster_list = list_create(slurm_destroy_char); } if (slurm_addto_char_list(reservation_cond->name_list, argv[i]+end)) set = 1; } else if (!strncasecmp(argv[i], "Names", MAX(command_len, 2))) { if (!reservation_cond->name_list) { reservation_cond->name_list = list_create(slurm_destroy_char); } if (slurm_addto_char_list(reservation_cond->name_list, argv[i]+end)) set = 1; } else if (!strncasecmp(argv[i], "Format", MAX(command_len, 1))) { if (format_list) slurm_addto_char_list(format_list, argv[i]+end); } else if (!strncasecmp(argv[i], "Ids", MAX(command_len, 1))) { if (!reservation_cond->id_list) { reservation_cond->id_list = list_create(slurm_destroy_char); } if (slurm_addto_char_list(reservation_cond->id_list, argv[i]+end)) set = 1; } else if (!strncasecmp(argv[i], "Nodes", MAX(command_len, 2))) { xfree(reservation_cond->nodes); reservation_cond->nodes = strip_quotes( argv[i]+end, NULL, 1); set = 1; } else if (!strncasecmp(argv[i], "Start", MAX(command_len, 5))) { reservation_cond->time_start = parse_time(argv[i]+end, 1); if (errno == ESLURM_INVALID_TIME_VALUE) exit_code = 1; else set = 1; } else if (!strncasecmp(argv[i], "End", MAX(command_len, 5))) { reservation_cond->time_end = parse_time(argv[i]+end, 1); if (errno == ESLURM_INVALID_TIME_VALUE) exit_code = 1; else set = 1; } else { exit_code=1; fprintf(stderr, " Unknown condition: %s\n" " Use keyword 'set' to modify value\n", argv[i]); } } (*start) = i; if (set) return 1; return 0; }
static int _set_rec(int *start, int argc, char *argv[], List name_list, slurmdb_qos_rec_t *qos) { int i, mins; int set = 0; int end = 0; int command_len = 0; int option = 0; for (i=(*start); i<argc; i++) { end = parse_option_end(argv[i]); if(!end) command_len=strlen(argv[i]); else { command_len=end-1; if(argv[i][end] == '=') { option = (int)argv[i][end-1]; end++; } } if (!strncasecmp (argv[i], "Where", MAX(command_len, 5))) { i--; break; } else if(!end && !strncasecmp(argv[i], "set", MAX(command_len, 3))) { continue; } else if(!end || !strncasecmp (argv[i], "Name", MAX(command_len, 1))) { if(name_list) slurm_addto_char_list(name_list, argv[i]+end); } else if (!strncasecmp (argv[i], "Description", MAX(command_len, 1))) { if(!qos->description) qos->description = strip_quotes(argv[i]+end, NULL, 1); set = 1; } else if (!strncasecmp (argv[i], "Flags", MAX(command_len, 2))) { if(!qos) continue; qos->flags = str_2_qos_flags(argv[i]+end, option); if (qos->flags == QOS_FLAG_NOTSET) { char *tmp_char = NULL; qos->flags = INFINITE; qos->flags &= (~QOS_FLAG_NOTSET & ~QOS_FLAG_ADD & ~QOS_FLAG_REMOVE); tmp_char = slurmdb_qos_flags_str(qos->flags); printf(" Unknown QOS flag used in:\n '%s'\n" " Valid QOS flags are\n '%s'\n", argv[i]+end, tmp_char); xfree(tmp_char); exit_code = 1; } else set = 1; } else if (!strncasecmp (argv[i], "GraceTime", MAX(command_len, 3))) { if (!qos) continue; if (get_uint(argv[i]+end, &qos->grace_time, "GraceTime") == SLURM_SUCCESS) { set = 1; } } else if (!strncasecmp (argv[i], "GrpCPUMins", MAX(command_len, 7))) { if(!qos) continue; if (get_uint64(argv[i]+end, &qos->grp_cpu_mins, "GrpCPUMins") == SLURM_SUCCESS) set = 1; } else if (!strncasecmp (argv[i], "GrpCPURunMins", MAX(command_len, 7))) { if(!qos) continue; if (get_uint64(argv[i]+end, &qos->grp_cpu_run_mins, "GrpCPURunMins") == SLURM_SUCCESS) set = 1; } else if (!strncasecmp (argv[i], "GrpCPUs", MAX(command_len, 7))) { if(!qos) continue; if (get_uint(argv[i]+end, &qos->grp_cpus, "GrpCPUs") == SLURM_SUCCESS) set = 1; } else if (!strncasecmp (argv[i], "GrpJobs", MAX(command_len, 4))) { if(!qos) continue; if (get_uint(argv[i]+end, &qos->grp_jobs, "GrpJobs") == SLURM_SUCCESS) set = 1; } else if (!strncasecmp (argv[i], "GrpMemory", MAX(command_len, 4))) { if(!qos) continue; if (get_uint(argv[i]+end, &qos->grp_mem, "GrpMemory") == SLURM_SUCCESS) set = 1; } else if (!strncasecmp (argv[i], "GrpNodes", MAX(command_len, 4))) { if(!qos) continue; if (get_uint(argv[i]+end, &qos->grp_nodes, "GrpNodes") == SLURM_SUCCESS) set = 1; } else if (!strncasecmp (argv[i], "GrpSubmitJobs", MAX(command_len, 4))) { if(!qos) continue; if (get_uint(argv[i]+end, &qos->grp_submit_jobs, "GrpSubmitJobs") == SLURM_SUCCESS) set = 1; } else if (!strncasecmp (argv[i], "GrpWall", MAX(command_len, 4))) { if(!qos) continue; mins = time_str2mins(argv[i]+end); if (mins != NO_VAL) { qos->grp_wall = (uint32_t) mins; set = 1; } else { exit_code=1; fprintf(stderr, " Bad GrpWall time format: %s\n", argv[i]); } } else if (!strncasecmp (argv[i], "MaxCPUMinsPerJob", MAX(command_len, 7))) { if(!qos) continue; if (get_uint64(argv[i]+end, &qos->max_cpu_mins_pj, "MaxCPUMins") == SLURM_SUCCESS) set = 1; } else if (!strncasecmp (argv[i], "MaxCPUsPerJob", MAX(command_len, 7))) { if(!qos) continue; if (get_uint(argv[i]+end, &qos->max_cpus_pj, "MaxCPUs") == SLURM_SUCCESS) set = 1; } else if (!strncasecmp (argv[i], "MaxCPUsPerUser", MAX(command_len, 11))) { if(!qos) continue; if (get_uint(argv[i]+end, &qos->max_cpus_pu, "MaxCPUsPerUser") == SLURM_SUCCESS) set = 1; } else if (!strncasecmp (argv[i], "MaxJobsPerUser", MAX(command_len, 4))) { if(!qos) continue; if (get_uint(argv[i]+end, &qos->max_jobs_pu, "MaxJobs") == SLURM_SUCCESS) set = 1; } else if (!strncasecmp (argv[i], "MaxNodesPerJob", MAX(command_len, 4))) { if(!qos) continue; if (get_uint(argv[i]+end, &qos->max_nodes_pj, "MaxNodes") == SLURM_SUCCESS) set = 1; } else if (!strncasecmp (argv[i], "MaxNodesPerUser", MAX(command_len, 8))) { if(!qos) continue; if (get_uint(argv[i]+end, &qos->max_nodes_pu, "MaxNodesPerUser") == SLURM_SUCCESS) set = 1; } else if (!strncasecmp (argv[i], "MaxSubmitJobsPerUser", MAX(command_len, 4))) { if(!qos) continue; if (get_uint(argv[i]+end, &qos->max_submit_jobs_pu, "MaxSubmitJobs") == SLURM_SUCCESS) set = 1; } else if (!strncasecmp (argv[i], "MaxWallDurationPerJob", MAX(command_len, 4))) { if(!qos) continue; mins = time_str2mins(argv[i]+end); if (mins != NO_VAL) { qos->max_wall_pj = (uint32_t) mins; set = 1; } else { exit_code=1; fprintf(stderr, " Bad MaxWall time format: %s\n", argv[i]); } } else if (!strncasecmp (argv[i], "PreemptMode", MAX(command_len, 8))) { if(!qos) continue; qos->preempt_mode = preempt_mode_num(argv[i]+end); if(qos->preempt_mode == (uint16_t)NO_VAL) { fprintf(stderr, " Bad Preempt Mode given: %s\n", argv[i]); exit_code = 1; } else if (qos->preempt_mode == PREEMPT_MODE_SUSPEND) { printf("PreemptType and PreemptMode " "values incompatible\n"); exit_code = 1; } else set = 1; /* Preempt needs to follow PreemptMode */ } else if (!strncasecmp (argv[i], "Preempt", MAX(command_len, 7))) { if(!qos) continue; if(!qos->preempt_list) qos->preempt_list = list_create(slurm_destroy_char); if(!g_qos_list) g_qos_list = acct_storage_g_get_qos( db_conn, my_uid, NULL); if(slurmdb_addto_qos_char_list(qos->preempt_list, g_qos_list, argv[i]+end, option)) set = 1; else exit_code = 1; } else if (!strncasecmp (argv[i], "Priority", MAX(command_len, 3))) { if(!qos) continue; if (get_uint(argv[i]+end, &qos->priority, "Priority") == SLURM_SUCCESS) set = 1; } else if (!strncasecmp (argv[i], "UsageFactor", MAX(command_len, 6))) { if(!qos) continue; if (get_double(argv[i]+end, &qos->usage_factor, "UsageFactor") == SLURM_SUCCESS) set = 1; } else if (!strncasecmp (argv[i], "UsageThreshold", MAX(command_len, 6))) { if(!qos) continue; if (get_double(argv[i]+end, &qos->usage_thres, "UsageThreshold") == SLURM_SUCCESS) set = 1; } else { exit_code = 1; printf(" Unknown option: %s\n" " Use keyword 'where' to modify condition\n", argv[i]); } } (*start) = i; return set; }
void run_command_set(char *args) /* {{{ */ { /** * set a variable in the statusbar * syntax: variable value */ var *this_var; char *message = NULL, *varname = NULL, *value = NULL; int ret = 0; /* parse args */ if (args != NULL) ret = sscanf(args, "%ms %m[^\n]", &varname, &value); if (ret != 2) { statusbar_message(cfg.statusbar_timeout, "syntax: set <variable> <value>"); tnc_fprintf(logfp, LOG_ERROR, "syntax: set <variable> <value> [%d](%s)", ret, args); goto cleanup; } /* find the variable */ this_var = (var *)find_var(varname); if (this_var==NULL) { statusbar_message(cfg.statusbar_timeout, "variable not found: %s", varname); goto cleanup; } /* check for permission */ if (this_var->perms == VAR_RO) { statusbar_message(cfg.statusbar_timeout, "variable is read only: %s", varname); goto cleanup; } if (this_var->perms == VAR_RC && tasklist != NULL) { statusbar_message(cfg.statusbar_timeout, "variable must be set in config: %s", varname); goto cleanup; } /* set the value */ switch (this_var->type) { case VAR_INT: ret = sscanf(value, "%d", (int *)this_var->ptr); break; case VAR_CHAR: ret = sscanf(value, "%c", (char *)this_var->ptr); break; case VAR_STR: if (*(char **)(this_var->ptr)!=NULL) free(*(char **)(this_var->ptr)); *(char **)(this_var->ptr) = calloc(strlen(value)+1, sizeof(char)); ret = NULL!=strcpy(*(char **)(this_var->ptr), value); if (ret) strip_quotes((char **)this_var->ptr, 1); break; default: ret = 0; break; } if (ret<=0) tnc_fprintf(logfp, LOG_ERROR, "failed to parse value from command: set %s %s", varname, value); /* acquire the value string and print it */ message = var_value_message(this_var, 1); statusbar_message(cfg.statusbar_timeout, message); cleanup: free(message); free(varname); free(value); return; } /* }}} */
void Def::process_time () { issue_diag (I_STAGE, false, 0, "processing %s section\n", lc_name); // nesting level int nesting_level = 0; time_def_found_ = true; while ((next = scanner_.next_token ()).token != Scanner::tok_time) { switch (next.token) { case Scanner::tok_end: next = scanner_.next_token (); if (next.token == Scanner::tok_time) { // end of numeric block if (nesting_level == 0) return; --nesting_level; scanner_.close (); } else issue_diag (E_SYNTAX, true, &next, "wrong section name in END directive\n"); break; case Scanner::tok_copy: { next = scanner_.next_token(); if (next.token != Scanner::tok_string) issue_diag (E_SYNTAX, true, &next, "expected string following \"copy\" directive\n"); // bump up the nesting level ++nesting_level; // open the file scanner_.open (get_pathname (strip_quotes (next.name), next.file)); // get comment char and escape char; // these informations are stored by the scanner while ((next = scanner_.next_token ()).token != Scanner::tok_time) { // the LC_IDENTIFICATION section may also have a // LC_TIME token that will mess up the parsing if (next.token == Scanner::tok_ident) { while ((next = scanner_.next_token ()).token != Scanner::tok_end); next = scanner_.next_token (); } } break; } case Scanner::tok_abday: { const std::size_t nelems = sizeof time_st_.abday / sizeof *time_st_.abday; next = extract_string_array (time_st_.abday, time_st_.wabday, nelems); break; } case Scanner::tok_day: { const std::size_t nelems = sizeof time_st_.day / sizeof *time_st_.day; next = extract_string_array (time_st_.day, time_st_.wday, nelems); break; } case Scanner::tok_abmon: { const std::size_t nelems = sizeof time_st_.abmon / sizeof *time_st_.abmon; next = extract_string_array (time_st_.abmon, time_st_.wabmon, nelems); break; } case Scanner::tok_mon: { const std::size_t nelems = sizeof time_st_.mon / sizeof *time_st_.mon; next = extract_string_array (time_st_.mon, time_st_.wmon, nelems); break; } case Scanner::tok_d_t_fmt: next = scanner_.next_token(); time_st_.d_t_fmt = convert_string (next.name); time_st_.wd_t_fmt = convert_wstring (next); break; case Scanner::tok_d_fmt: next = scanner_.next_token(); time_st_.d_fmt = convert_string (next.name); time_st_.wd_fmt = convert_wstring (next); break; case Scanner::tok_t_fmt: next = scanner_.next_token(); time_st_.t_fmt = convert_string (next.name); time_st_.wt_fmt = convert_wstring (next); break; case Scanner::tok_am_pm: { const std::size_t nelems = sizeof time_st_.am_pm / sizeof *time_st_.am_pm; next = extract_string_array (time_st_.am_pm, time_st_.wam_pm, nelems); break; } case Scanner::tok_t_fmt_ampm: next = scanner_.next_token(); time_st_.t_fmt_ampm = convert_string (next.name); time_st_.wt_fmt_ampm = convert_wstring (next); break; // The time_get and time_put facets do not make use of eras or // alternate digits, so we will ignore this part of the locale // definition case Scanner::tok_era: while ((next = scanner_.next_token()).token == Scanner::tok_string) parse_era (next); break; case Scanner::tok_era_d_fmt: next = scanner_.next_token(); time_st_.era_d_fmt = convert_string (next.name); time_st_.wera_d_fmt = convert_wstring (next); break; case Scanner::tok_era_t_fmt: next = scanner_.next_token(); time_st_.era_t_fmt = convert_string (next.name); time_st_.wera_t_fmt = convert_wstring (next); break; case Scanner::tok_era_d_t_fmt: next = scanner_.next_token(); time_st_.era_d_t_fmt = convert_string (next.name); time_st_.wera_d_t_fmt = convert_wstring (next); break; case Scanner::tok_alt_digits: while ((next = scanner_.next_token()).token == Scanner::tok_string) { alt_digit_t digit; digit.n_alt_digit = convert_string (next.name); digit.w_alt_digit = convert_wstring (next); digit.n_offset = 0; digit.w_offset = 0; alt_digits_.push_back (digit); } break; default: break; } } }
void SimpleJsonParser::parse( SimpleJsonTokenizer& tokenizer ) { #define IS_BREAK( t, b ) (t[0] == b && t[1] == '\0') enum ParseState { SCAN=1, ARRAY, PAIR, PAIR_COLON, RVALUE, RVALUE_SEPARATOR }; ParseState state = SCAN; char tag_name[MAXTAGNAMELEN+1]; CString array_index; reset(); push( this ); while ( tokenizer.hasToken() ) { LPSTR token = tokenizer.nextToken(); switch ( state ) { case SCAN: if ( IS_BREAK( token, '[' ) ) { // Start of array setType( JSONARRAY ); state = RVALUE; break; } else if ( IS_BREAK( token, '{' ) ) { // Start of object setType( JSONOBJECT ); state = PAIR; break; } throw std::exception( "Parser expected opening object or array" ); case PAIR: // Check for empty object if ( IS_BREAK( token, '}' ) && top()->getType() == JSONOBJECT && top()->valueCount() == 0 ) { pop(); state = RVALUE_SEPARATOR; break; } strcpy_s( tag_name, strip_quotes( token ) ); state = PAIR_COLON; break; case PAIR_COLON: if ( !IS_BREAK( token, ':' ) ) throw std::exception( "Parser expecting colon seperator" ); state = RVALUE; break; case RVALUE: { if ( IS_BREAK( token, ']' ) ) { // Empty array if ( top()->getType() != JSONARRAY ) throw std::exception( "Unexpected array closing bracket" ); pop(); state = RVALUE_SEPARATOR; break; } JsonNode* node = top(); if ( node->getType() == JSONARRAY ) { tag_name[0] = '\0'; } else if ( node->has_key( tag_name ) ) { CString error; error.Format( "Duplicate JSON tag name '%s'", tag_name ); throw std::exception( (LPCSTR)error ); } if ( IS_BREAK( token, '[' ) ) { push( node->setValue( JSONARRAY, tag_name ) ); state = RVALUE; break; } if ( IS_BREAK( token, '{' )) { push( node->setValue( JSONOBJECT, tag_name ) ); state = PAIR; break; } // Add a constant to current node container if ( node->getType() != JSONOBJECT && node->getType() != JSONARRAY) throw std::exception( "Parser expecting container JSON node" ); node->setValue( strip_quotes( token ), tag_name ); state = RVALUE_SEPARATOR; break; } case RVALUE_SEPARATOR: { JsonNode* node = m_nodeStack[m_stack_ptr-1]; if ( IS_BREAK( token, ',' ) ) { state = node->getType() == JSONARRAY ? RVALUE : PAIR; break; } if ( IS_BREAK( token, '}' ) && node->getType() == JSONOBJECT ) { pop(); break; } if ( IS_BREAK( token, ']' ) && node->getType() == JSONARRAY ) { if ( !node->validateArray( ) ) { CString error; error.Format( "Mixed object types in '%s'", node->getTagName() ); throw std::exception( (LPCSTR)error ); } pop(); break; } throw std::exception( "Parser expecting object or array seperator" ); } } } if ( stackSize() > 0 ) throw std::exception( "Unclosed JSON objects detected" ); }
// ---------------------------------------------------------------------------- // void SimpleJsonParser::parse( LPCSTR json_data ) { m_values.clear(); // May be a simple null nalue if ( !_strcmpi( "null", json_data ) ) return; std::vector<CString> tokens = tokenize( json_data, "{},[]:", true ); ParseState state = OPENING_BRACE; LPCSTR tag_name = NULL; // For embedded arrays of objects int brackets = 0; int braces = 0; for ( std::vector<CString>::iterator it=tokens.begin(); it != tokens.end(); ++it ) { //printf( "%s\n", (*it) ); switch ( state ) { case OPENING_BRACE: if ( (*it) == "[" ) { // Simple array with no name - eek! tag_name = ""; m_values[ tag_name ] = ""; state = ARRAY_VALUE_OR_SEPARATOR; brackets=1; break; } else if ( (*it) != "{" ) throw std::exception( "Parser expecting opening brace" ); state = TAG_NAME; break; case TAG_NAME: tag_name = strip_quotes( (*it) ); state = COLON; break; case COLON: if ( (*it) != ":" ) throw std::exception( "Parser expecting colon seperator" ); state = TAG_VALUE; break; case TAG_VALUE: if ( (*it) == "[" ) { m_values[ tag_name ] = ""; state = ARRAY_VALUE_OR_SEPARATOR; brackets = 1; break; } if ( (*it) == "{" ) { m_values[ tag_name ] = "\""; m_values[ tag_name ] += (*it); state = OBJECT; braces = 1; break; } m_values[ tag_name ] = strip_quotes( (*it) ); state = TAG_SEPARATOR; break; case TAG_SEPARATOR: if ( (*it) == "," ) state = TAG_NAME; else if ( (*it) == "}" ) state = DONE; else throw std::exception( "Parser expecting tag seperator" ); break; case DONE: throw std::exception( "Parser unexpected data after JSON obejct end" ); case ARRAY_VALUE_OR_SEPARATOR: if ( "]" == (*it) ) { brackets--; if ( brackets == 0 ) state = TAG_SEPARATOR; break; } else if ( "{" == (*it) ) { state = ARRAY_OF_OBJECTS; m_values[ tag_name ] = "\""; m_values[ tag_name ] += (*it); braces = 1; break; } else if ( "[" == (*it) ) { m_values[ tag_name ] += "\""; m_values[ tag_name ] += (*it); brackets++; break; } case ARRAY_VALUE: m_values[ tag_name ] += strip_quotes( (*it) ); state = ARRAY_SEPARATOR; break; case ARRAY_SEPARATOR: if ( "]" == (*it) ) { brackets--; if ( brackets == 0 ) { state = TAG_SEPARATOR; break; } m_values[ tag_name ] += (*it); m_values[ tag_name ] += "\""; } else if ( (*it) == "," ) { m_values[ tag_name ] += (*it); state = ARRAY_VALUE_OR_SEPARATOR; } else throw std::exception( "Parser expecting array item seperator" ); break; case ARRAY_OF_OBJECTS: { if ( "]" == (*it) ) { brackets--; if ( brackets == 0 ) { state = TAG_SEPARATOR; break; } } else if ( "[" == (*it) ) brackets++; else if ( "{" == (*it) ) braces++; else if ( "}" == (*it) ) braces--; CString escaped ( (*it) ); escaped.Replace( "\"", "\\\"" ); m_values[ tag_name ] += escaped; if ( !braces ) m_values[ tag_name ] += "\""; break; } case OBJECT: { if ( "}" == (*it) ) { braces--; if ( braces == 0 ) { m_values[ tag_name ] += (*it); m_values[ tag_name ] += "\""; state = TAG_SEPARATOR; break; } } else if ( "{" == (*it) ) braces++; CString escaped ( (*it) ); escaped.Replace( "\"", "\\\"" ); m_values[ tag_name ] += escaped; break; } } } }
void Def:: process_ctype () { issue_diag (I_STAGE, false, 0, "processing %s section\n", lc_name); ctype_def_found_ = true; // used in processing the copy/include directive int nesting_level = 0; while ((next = scanner_.next_token()).token != Scanner::tok_ctype) { switch(next.token) { case Scanner::tok_copy: { // when we see the copy directive in the ctype definition we // are going to either create the shared database and create a // symbolic link to it, or we are going to create a symbolic link // to the already existing shared ctype database. next = scanner_.next_token(); if (next.token != Scanner::tok_string) issue_diag (E_SYNTAX, true, &next, "expected string following \"copy\" directive\n"); #if !defined (_WIN32) && !defined (__CYGWIN__) ctype_symlink_ = true; // first lets make sure that the ctype database for this // locale hasn't already been generated ctype_filename_ = output_name_; // strip off the last directory ctype_filename_ = ctype_filename_.substr (0, ctype_filename_.rfind (_RWSTD_PATH_SEP, ctype_filename_.length() - 1) + 1); ctype_filename_ += strip_quotes(next.name); ctype_filename_ += ".ctype."; ctype_filename_ += charmap_.get_charmap_name(); std::ifstream f (ctype_filename_.c_str(), std::ios::binary); if (f) { // the database exists so simply create a sym link to it ctype_written_ = true; f.close(); continue; } #endif // !_WIN32 && !__CYGWIN__ // bump up the nesting level nesting_level++; issue_diag (I_STAGE, false, 0, "processing copy directive\n"); // open the file scanner_.open (get_pathname (strip_quotes (next.name), next.file)); // get comment char and escape char; // these informations are stored by the scanner while ((next = scanner_.next_token ()).token != Scanner::tok_ctype ){ // the LC_IDENTIFICATION section may also have a // LC_CTYPE token that will mess up the parsing if (next.token == Scanner::tok_ident) { while ((next = scanner_.next_token()).token != Scanner::tok_end ); next = scanner_.next_token(); } } break; } case Scanner::tok_nl: break; case Scanner::tok_upper: process_mask (std::ctype_base::upper, "upper"); break; case Scanner::tok_lower: process_mask (std::ctype_base::lower, "lower"); break; case Scanner::tok_alpha: process_mask (std::ctype_base::alpha, "alpha"); break; case Scanner::tok_digit: process_mask (std::ctype_base::digit, "digit"); break; case Scanner::tok_space: process_mask (std::ctype_base::space, "space"); break; case Scanner::tok_cntrl: process_mask (std::ctype_base::cntrl, "cntrl"); break; case Scanner::tok_punct: process_mask (std::ctype_base::punct, "punct"); break; case Scanner::tok_graph: process_mask (std::ctype_base::graph, "graph"); break; case Scanner::tok_print: process_mask (std::ctype_base::print, "print"); break; case Scanner::tok_xdigit: process_mask (std::ctype_base::xdigit, "xdigit"); break; case Scanner::tok_toupper: process_upper_lower (Scanner::tok_toupper); break; case Scanner::tok_tolower: process_upper_lower (Scanner::tok_tolower); break; case Scanner::tok_blank: scanner_.ignore_line(); break; case Scanner::tok_xlit_start: process_xlit (); break; case Scanner::tok_end: next = scanner_.next_token(); if (next.token == Scanner::tok_ctype) { // end of ctype block if (nesting_level == 0) return; nesting_level--; scanner_.close (); } else issue_diag (E_SYNTAX, true, &next, "wrong section name in END directive\n"); break; default: // ignore locale specific character classes because the c++ // library does not make use of them scanner_.ignore_line(); break; } } }
void Def:: process_xlit () { issue_diag (I_STAGE, false, 0, "processing transliteration\n"); std::size_t nchars = 0; // used in processing the include directive int nesting_level = 0; std::list<std::string> file_list; while (true) { next = scanner_.next_token (); switch (next.token) { case Scanner::tok_include: { // extract all file names from the list std::list<std::string> tmp_list; while (next.token != Scanner::tok_nl) { next = scanner_.next_token (); if (next.token == Scanner::tok_string && next.name.size () > 2) tmp_list.push_back (next.name); } // insert this list into the main list - at beginning file_list.insert (file_list.begin (), tmp_list.begin (), tmp_list.end ()); // get the top of the list std::string fname (file_list.front ()); file_list.pop_front (); // bump up the nesting level nesting_level++; // get the full path for the included file and open it scanner_.open (get_pathname (strip_quotes (fname), next.file)); // get comment char and escape char; // these informations are stored by the scanner while ((next = scanner_.next_token ()).token != Scanner::tok_xlit_start ); break; } case Scanner::tok_sym_name: { process_xlit_statement (nchars); break; } case Scanner::tok_xlit_end: { if (nesting_level == 0) return; // decrement nesting level, close opened file nesting_level--; scanner_.close (); // check if the list of files is empty or not if (file_list.empty ()) break; // if not take the following file and open it std::string fname (file_list.front ()); file_list.pop_front (); // bump up the nesting level nesting_level++; // get the full path for the included file and open it scanner_.open (get_pathname (strip_quotes (fname), next.file)); // get comment char and escape char; // these informations are stored by the scanner while ((next = scanner_.next_token ()).token != Scanner::tok_xlit_start); } default: break; } } issue_diag (I_STAGE, false, 0, "done processing transliteration " "(%lu tokens, %lu characters)"); }
char *workspace_next_name(const char *output_name) { sway_log(L_DEBUG, "Workspace: Generating new workspace name for output %s", output_name); int i; int l = 1; // Scan all workspace bindings to find the next available workspace name, // if none are found/available then default to a number struct sway_mode *mode = config->current_mode; int order = INT_MAX; char *target = NULL; for (i = 0; i < mode->bindings->length; ++i) { struct sway_binding *binding = mode->bindings->items[i]; char *cmdlist = strdup(binding->command); char *dup = cmdlist; char *name = NULL; // workspace n char *cmd = argsep(&cmdlist, " "); if (cmdlist) { name = argsep(&cmdlist, " ,;"); } if (strcmp("workspace", cmd) == 0 && name) { sway_log(L_DEBUG, "Got valid workspace command for target: '%s'", name); char *_target = strdup(name); strip_quotes(_target); while (isspace(*_target)) _target++; // Make sure that the command references an actual workspace // not a command about workspaces if (strcmp(_target, "next") == 0 || strcmp(_target, "prev") == 0 || strcmp(_target, "next_on_output") == 0 || strcmp(_target, "prev_on_output") == 0 || strcmp(_target, "number") == 0 || strcmp(_target, "back_and_forth") == 0 || strcmp(_target, "current") == 0) { free(_target); free(dup); continue; } // Make sure that the workspace doesn't already exist if (workspace_by_name(_target)) { free(_target); free(dup); continue; } // make sure that the workspace can appear on the given // output if (!workspace_valid_on_output(output_name, _target)) { free(_target); free(dup); continue; } if (binding->order < order) { order = binding->order; free(target); target = _target; sway_log(L_DEBUG, "Workspace: Found free name %s", _target); } } free(dup); } if (target != NULL) { return target; } // As a fall back, get the current number of active workspaces // and return that + 1 for the next workspace's name int ws_num = root_container.children->length; if (ws_num >= 10) { l = 2; } else if (ws_num >= 100) { l = 3; } char *name = malloc(l + 1); sprintf(name, "%d", ws_num++); return name; }
static int _set_rec(int *start, int argc, char *argv[], List acct_list, List cluster_list, slurmdb_account_rec_t *acct, slurmdb_association_rec_t *assoc) { int i; int u_set = 0; int a_set = 0; int end = 0; int command_len = 0; int option = 0; for (i=(*start); i<argc; i++) { end = parse_option_end(argv[i]); if (!end) command_len=strlen(argv[i]); else { command_len=end-1; if (argv[i][end] == '=') { option = (int)argv[i][end-1]; end++; } } if (!strncasecmp(argv[i], "Where", MAX(command_len, 5))) { i--; break; } else if (!end && !strncasecmp(argv[i], "set", MAX(command_len, 3))) { continue; } else if (!end || !strncasecmp(argv[i], "Accounts", MAX(command_len, 1)) || !strncasecmp(argv[i], "Names", MAX(command_len, 1)) || !strncasecmp(argv[i], "Acct", MAX(command_len, 4))) { if (acct_list) slurm_addto_char_list(acct_list, argv[i]+end); else { exit_code=1; fprintf(stderr, " Can't modify the name " "of an account\n"); } } else if (!strncasecmp(argv[i], "Clusters", MAX(command_len, 1))) { if (cluster_list) slurm_addto_char_list(cluster_list, argv[i]+end); else { exit_code=1; fprintf(stderr, " Can't modify the cluster " "of an account\n"); } } else if (!strncasecmp(argv[i], "Description", MAX(command_len, 1))) { acct->description = strip_quotes(argv[i]+end, NULL, 1); u_set = 1; } else if (!strncasecmp(argv[i], "Organization", MAX(command_len, 1))) { acct->organization = strip_quotes(argv[i]+end, NULL, 1); u_set = 1; } else if (!strncasecmp (argv[i], "RawUsage", MAX(command_len, 7))) { uint32_t usage; if (!assoc) continue; assoc->usage = xmalloc(sizeof( assoc_mgr_association_usage_t)); if (get_uint(argv[i]+end, &usage, "RawUsage") == SLURM_SUCCESS) { assoc->usage->usage_raw = usage; a_set = 1; } } else if (!assoc || (assoc && !(a_set = sacctmgr_set_association_rec( assoc, argv[i], argv[i]+end, command_len, option)))) { exit_code=1; fprintf(stderr, " Unknown option: %s\n" " Use keyword 'where' to modify condition\n", argv[i]); } } (*start) = i; if (u_set && a_set) return 3; else if (a_set) return 2; else if (u_set) return 1; return 0; }
/** * Command line should look like this: * * <appname> [--analyze="title=(true|false|auto);delim=('<delimeter>'|auto)"] [--select="<enumerate_columns sep by ','>"] [--filter="<col><=,!= <,>, <=, >='><value> <and,or,xor>..."] [--smooth=<number_of_lines>] [--format="delim='<delim>',align=<true,false>"] [input_file] [output_file] * */ void command_line_parser::parse_cmdline(int argc, char *argv[], std::string &ifile_name, std::string &ofile_name, configuration_t &cfg) { // for (size_t i = 0; i < argc; i++) { // std::cout << i << "\t" << argv[i] << std::endl; // } struct option options[] = { // Analyzer-related configuration options { "has_header", optional_argument, nullptr, 'a'}, { "trim_lines", optional_argument, nullptr, 'l'}, { "trim_columns", optional_argument, nullptr, 't'}, { "trim_quotes", optional_argument, nullptr, 'q' }, { "ignore_empty_columns", optional_argument, nullptr, 'e' }, { "column_separator", required_argument, nullptr, 'c'}, { "buffer_size", required_argument, nullptr, 'b'}, { "rebase", required_argument, nullptr, 'r'}, // select-related configuration options { "select", required_argument, nullptr, 's'}, // filter-related configuration options { "filter", required_argument, nullptr, 'f'}, // smoothing-related filter options { "smooth", required_argument, nullptr, 'm'}, // statistics-related filter option { "statistics", optional_argument, nullptr, 'i'}, // output-related configuration options { "output_empty_lines", optional_argument, nullptr, 'E'}, // 0 means none, 1 means only one for a group of empty lines, 2 means all { "output_comment_lines", optional_argument, nullptr, 'C'}, // if true comment lines are printed { "output_header_line", optional_argument, nullptr, 'H'}, // if true the header line is printed { "align_columns", optional_argument, nullptr, 'A'}, // if true the columns are right justified and aligned { "header_column_filler_char", required_argument, nullptr, 'E'}, // character used to fill right aligned header strings { "number_column_filler_char", required_argument, nullptr, 'N'}, // character used to fill right aligned data columns of a number type { "string_column_filler_char", required_argument, nullptr, 'S'}, // character used to fill right aligned data columns of a string type { "flt_precision", required_argument, nullptr, 'F'}, // precision of float data columns { "int_length", required_argument, nullptr, 'I'}, // length of a column in characters { "output_datetime_format", required_argument, nullptr, 'D'}, // defines the datetime format for the output for all columns { "output_separator", required_argument, nullptr, 'P'}, // defines the character that separates columns in the output { "order_columns", required_argument, nullptr, 'O' }, // defines in which way the columns shall be sorted { "help", no_argument, nullptr, 'h' } }; int oc; int opts_index = 0; while ((oc = getopt_long(argc, argv, "+a::l::t::q::e::c:b:r:s:i::f:m:E::R::C::H::A::L:N:S:F:I:D:P:O:h", options, &opts_index)) != -1) { std::string stmp; if (optarg) { stmp = optarg; strip_quotes(stmp); } else { stmp = "1"; } switch (oc) { case 'a': // std::cerr << "optarg: \"" << optarg << "\"" << std::endl; switch (stmp[0]) { case '1': cfg.header_detection_mode = 1; break; case '0': cfg.header_detection_mode = -1; break; case 'a': cfg.header_detection_mode = 0; break; default: cfg.header_detection_mode = 0; break; } break; case 'l': if ((cfg.do_help = !check_bool_cmdline_param(stmp, cfg.trim_lines, "trim_lines [l]"))) return; break; case 't': if ((cfg.do_help = !check_bool_cmdline_param(stmp, cfg.trim_columns, "trim_columns [t]"))) return; break; case 'q': if ((cfg.do_help = !check_bool_cmdline_param(stmp, cfg.trim_quotes, "trim_quotes [q]"))) return; break; case 'e': if ((cfg.do_help = !check_bool_cmdline_param(stmp, cfg.ignore_empty_columns, "ignore_empty_columns [e]"))) return; break; case 'c': cfg.separator_auto_detection = false; if (stmp.length() > 0) { cfg.separator = stmp[0]; } else { cfg.do_help = true; std::cerr << "Option --separator [c] requires one character as parameter but found an empty string." << std::endl; return; } break; case 'b': if ((cfg.do_help = !check_uint_cmdline_param(stmp, cfg.buffer_size, "buffer_size [b]"))) { return; } break; case 'r': { cfg.do_rebase = true; strip_quotes(stmp); std::vector<std::string> rebase_pairs = split(stmp, /*bool ignore_quotes = */ false, /* bool ignore_empty = */ true, /* const std::string &delimeters = */ "," /* const std::string "es = "\"\'" */ ); for (std::string s : rebase_pairs) { std::vector<std::string> key_value_pair = split(s, /* bool ignore_quotes = */ false, /* bool ignore_empty = */ false, /* const std::string &delimeters = */ ":" /* const std::string "es = "\"\'" */ ); if (key_value_pair.size() != 2) { throw std::runtime_error("can't parse the rebase string. Error parsing this part: " + s); } cfg.rebase_columns.push_back(s); } cfg.selected_column_titles.shrink_to_fit(); cfg.selected_columns.resize(cfg.selected_column_titles.size()); for (size_t i = 0; i < cfg.selected_column_titles.size(); i++) { long long rslt; size_t len; if (parse_int(cfg.selected_column_titles[i], rslt, len)) { cfg.selected_columns[i] = (size_t) rslt; } else { cfg.selected_columns[i] = std::string::npos; } } } break; case 's': cfg.select_columns = 1; cfg.selected_column_titles = split(stmp, /*bool ignore_quotes = */ true, /* bool ignore_empty = */ true, /* const std::string &delimeters = */ "," /* const std::string "es = "\"\'" */ ); cfg.selected_column_titles.shrink_to_fit(); cfg.selected_columns.resize(cfg.selected_column_titles.size()); for (size_t i = 0; i < cfg.selected_column_titles.size(); i++) { long long rslt; size_t len; if (parse_int(cfg.selected_column_titles[i], rslt, len)) { cfg.selected_columns[i] = (size_t) rslt; } else { cfg.selected_columns[i] = std::string::npos; } } break; case 'i': { // stmp contains a list looking like this: "counter, Mean,vAriance , TOTAL" stmp = strip(stmp); std::transform(stmp.begin(), stmp.end(), stmp.begin(), ::tolower); // since parameter is given we output to true cfg.output_statistics = true; // set output to false for all values to begin with for (bool v : cfg.statistics_output_selector) { v = false; } if (stmp == "none") { // none mean we deactivate output cfg.output_statistics = false; } else if (stmp == "all") { // all means we want all output cfg.output_statistics = true; for (bool v : cfg.statistics_output_selector) { v = true; } } else { // neither none nor all: it must be a list of selected values std::vector<std::string> selected_statistics_values = split(stmp, /*bool ignore_quotes = */ true, /* bool ignore_empty = */ true, /* const std::string &delimeters = */ "," /* const std::string "es = "\"\'" */ ); for (std::string& x : selected_statistics_values) { x = strip(x); // if x is a supported name for a statistics value we set it to true, or we throw an error. auto it = statistics_name_dictionary.find(x); if (it == statistics_name_dictionary.end()) { throw std::runtime_error("statistics calculation for \"" + x + "\" is not supported"); } cfg.statistics_output_selector[it->second] = true; } } } case 'f': stmp = strip(stmp); // std::cerr << "stmp = \"" << stmp << "\"" << std::endl; // split into column, comparator, and value with regular expression // -f"@'abc' < 5 and @2 == 'x' or @'xyz' <= 17 > { cfg.filter_expression.parse_filter(stmp); /* size_t i = 0; while (i < stmp.length()) { std::string column_name; size_t column_number; if (!parse_column_name(stmp, i, column_name, column_number)) { cfg.do_help = 1; return ; } comparator_t comparator; if (!parse_comparator(stmp, i, comparator)) { cfg.do_help = 1; return ; } std::string value; if (!parse_value(stmp, i, value)) { cfg.do_help = 1; return ; } bool_operator_t op; if (!parse_bool_operator(stmp, i, op)) { cfg.do_help = 1; return ; } comparison_statement_t cs(column_name, column_number, comparator, value, op); cfg.comparison_statements.push_back(cs); } */ } break; case 'm': { long long rslt; size_t len; if (parse_int(stmp, rslt, len)) { cfg.smoothing_window_size = (size_t) rslt; } else { cfg.do_help = true; std::cerr << "Illegal command line parameter: smooth length must be a number but it was \""; std::cerr << stmp << "\"" << std::endl; return; } } break; case 'R': { stmp = strip(stmp); bool set_raw_output = true; if (stmp.length() > 0) { if (stmp[0] == '0') { set_raw_output = false; } } cfg.output_raw = set_raw_output; } case 'E': // { "output_empty_lines", optional_argument, nullptr, 'E'}, // 0 means none, 1 means only one for a group of empty lines, 2 means all switch(stmp[0]) { case '0': cfg.output_empty_lines = 0; break; case '1': cfg.output_empty_lines = 1; break; case '2': cfg.output_empty_lines = 2; break; default: cfg.do_help = true; std::cerr << "Illegal command line parameter: output_empty_lines [E] must be 0, 1, or 2 but was \""; std::cerr << stmp << "\"" << std::endl; return; } break; case 'C': // { "output_comment_lines", optional_argument, nullptr, 'C'}, // if true comment lines are printed if ((cfg.do_help = !check_bool_cmdline_param(stmp, cfg.output_comment_lines, "output_comment_lines [C]"))) return; break; case 'H': // { "output_header_line", optional_argument, nullptr, 'H'}, // if true the header line is printed if ((cfg.do_help = !check_bool_cmdline_param(stmp, cfg.output_header_line, "output_header_line [H]"))) return; break; case 'A': // { "align_columns", optional_argument, nullptr, 'A'}, // if true the columns are right justified and aligned if ((cfg.do_help = !check_bool_cmdline_param(stmp, cfg.align_columns, "align_columns [A]"))) return; break; case 'L': // { "header_column_filler_char", required_argument, nullptr, 'E'}, // character used to fill right aligned header strings if (stmp.length() > 0) { cfg.header_column_filler_char = stmp[0]; } else { std::cerr << "Empty --header_column_filler_char option [-L] - ignored." << std::endl; } break; case 'N': // { "number_column_filler_char", required_argument, nullptr, 'N'}, // character used to fill right aligned data columns of a number type if (stmp.length() > 0) { cfg.number_column_filler_char = stmp[0]; } else { std::cerr << "Empty --number_column_filler_char option [-N] - ignored." << std::endl; } break; case 'S': // { "string_column_filler_char", required_argument, nullptr, 'S'}, // character used to fill right aligned data columns of a string type if (stmp.length() > 0) { cfg.string_column_filler_char = stmp[0]; } else { std::cerr << "Empty --string_filler_char option [-S] - ignored." << std::endl; } break; case 'F': // { "flt_precision", required_argument, nullptr, 'F'}, // precision of float data columns if (!(cfg.do_help = check_uint_cmdline_param(stmp, cfg.flt_precission, "flt_precision [F]"))) return; break; case 'I': // { "int_length", required_argument, nullptr, 'I'}, // length of a column in characters if (!(cfg.do_help = check_uint_cmdline_param(stmp, cfg.int_length, "int_length [I]"))) return; break; case 'D': // { "output_datetime_format", required_argument, nullptr, 'D', if (stmp.length() > 0) { cfg.output_datetime_format = stmp; } else { std::cerr << "Empty --outout_datetime_format option [-D] - ignored." << std::endl; } break; case 'P': // { "output_separator", required_argument, nullptr, 'P'}, if (stmp.length() > 0) { cfg.output_separator = stmp; } else { std::cerr << "Empty number output separator option [P] - ignored." << std::endl; } break; case 'O': // { "order_columns", required_argument, nullptr, 'O' } // Here are some example sort criterion: // -O"by_avg [2, 6:9, 11:13, 4, 'whatever_column']" // -O"by_title" // -O"by_max ['whatever_column':]" // -O"by_min_descending [:7]" // So for the parameter reader we need to read the first token anything until we have a space, // a '[', or the end of the string. { cfg.order_columns = true; size_t i = stmp.find_first_of("[ \t\n\r"); if (i == std::string::npos) { cfg.order_criterion_string = stmp; cfg.order_range_string = ""; } else { cfg.order_criterion_string = stmp.substr(0, i); cfg.order_range_string = strip(stmp.substr(i)); if ((cfg.order_range_string.front() != '[') || (cfg.order_range_string.back() != ']')) { throw std::runtime_error("Order range incorrecltly specified: \"" + stmp + "\"."); } cfg.order_range_string = cfg.order_range_string.substr(1, cfg.order_range_string.length() - 2); // all other parsing is done when the analyzer has finished it's job. } // check if the order criterion is ok: auto it = order_criteria_lookup_dict.find(cfg.order_criterion_string); if (it != order_criteria_lookup_dict.end()) { cfg.order_criterion = it->second; } } break; case 'h': cfg.do_help = true; std::cerr << "do_help = true" << std::endl; return; case ':': // missing option argument std::cerr << argv[0] << " option '-" << (char) optopt << "' requires an argument" << std::endl; break; case '?': default: // invalid option std::cerr << argv[0] << " option '-" << (char) optopt << "' is invalid: ignored." << std::endl; break; } // std::cerr << "opts_index = " << opts_index << std::endl; opts_index = 0; } //std::cerr << "optind: " << optind << std::endl; //std::cerr << "argc: " << argc << std::endl; if (argc > optind) { ifile_name = argv[optind]; } if (argc > optind+1) { ofile_name = argv[optind+1]; } }
static void parse_naptr(const ldns_rr *naptr, const char *number, enum_record_t **results) { char *str = ldns_rr2str(naptr); char *argv[11] = { 0 }; int i, argc; char *pack[4] = { 0 }; int packc; char *p; int order = 10; int preference = 100; char *service = NULL; char *packstr; char *regex, *replace; if (zstr(str)) { if (str != NULL) { /* In this case ldns_rr2str returned a malloc'd null terminated string */ switch_safe_free(str); } return; } for (p = str; p && *p; p++) { if (*p == '\t') *p = ' '; if (*p == ' ' && *(p+1) == '.') *p = '\0'; } argc = switch_split(str, ' ', argv); for (i = 0; i < argc; i++) { if (i > 0) { strip_quotes(argv[i]); } } service = argv[7]; packstr = argv[8]; if (zstr(service) || zstr(packstr)) { goto end; } if (!zstr(argv[4])) { order = atoi(argv[4]); } if (!zstr(argv[5])) { preference = atoi(argv[5]); } if ((packc = switch_split(packstr, '!', pack))) { regex = pack[1]; replace = pack[2]; } else { goto end; } for (p = replace; p && *p; p++) { if (*p == '\\') { *p = '$'; } } if (service && regex && replace) { switch_regex_t *re = NULL, *re2 = NULL; int proceed = 0, ovector[30]; char *substituted = NULL; char *substituted_2 = NULL; char *orig_uri; char *uri_expanded = NULL; enum_route_t *route; int supported = 0; uint32_t len = 0; if ((proceed = switch_regex_perform(number, regex, &re, ovector, sizeof(ovector) / sizeof(ovector[0])))) { if (strchr(regex, '(')) { len = (uint32_t) (strlen(number) + strlen(replace) + 10) * proceed; if (!(substituted = malloc(len))) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error!\n"); switch_regex_safe_free(re); goto end; } memset(substituted, 0, len); switch_perform_substitution(re, proceed, replace, number, substituted, len, ovector); orig_uri = substituted; } else { orig_uri = replace; } switch_mutex_lock(MUTEX); for (route = globals.route_order; route; route = route->next) { char *uri = orig_uri; if (strcasecmp(service, route->service)) { continue; } if ((proceed = switch_regex_perform(uri, route->regex, &re2, ovector, sizeof(ovector) / sizeof(ovector[0])))) { switch_event_t *event = NULL; if (strchr(route->regex, '(')) { len = (uint32_t) (strlen(uri) + strlen(route->replace) + 10) * proceed; if (!(substituted_2 = malloc(len))) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error!\n"); switch_safe_free(substituted); switch_regex_safe_free(re); switch_regex_safe_free(re2); switch_mutex_unlock(MUTEX); goto end; } memset(substituted_2, 0, len); switch_perform_substitution(re2, proceed, route->replace, uri, substituted_2, len, ovector); uri = substituted_2; } else { uri = route->replace; } switch_event_create(&event, SWITCH_EVENT_REQUEST_PARAMS); uri_expanded = switch_event_expand_headers(event, uri); switch_event_destroy(&event); if (uri_expanded == uri) { uri_expanded = NULL; } else { uri = uri_expanded; } supported++; add_result(results, order, preference, service, uri, supported); } switch_safe_free(uri_expanded); switch_safe_free(substituted_2); switch_regex_safe_free(re2); } switch_mutex_unlock(MUTEX); if (!supported) { add_result(results, order, preference, service, orig_uri, 0); } switch_safe_free(substituted); switch_regex_safe_free(re); } } end: switch_safe_free(str); return; }
static int XCOPY_ParseCommandLine(WCHAR *suppliedsource, WCHAR *supplieddestination, DWORD *pflags) { const WCHAR EXCLUDE[] = {'E', 'X', 'C', 'L', 'U', 'D', 'E', ':', 0}; DWORD flags = *pflags; WCHAR *cmdline, *word, *end, *next; int rc = RC_INITERROR; cmdline = _wcsdup(GetCommandLineW()); if (cmdline == NULL) return rc; /* Skip first arg, which is the program name */ if ((rc = find_end_of_word(cmdline, &word)) != RC_OK) goto out; word = skip_whitespace(word); while (*word) { WCHAR first; if ((rc = find_end_of_word(word, &end)) != RC_OK) goto out; next = skip_whitespace(end); first = word[0]; *end = '\0'; strip_quotes(word, &end); WINE_TRACE("Processing Arg: '%s'\n", wine_dbgstr_w(word)); /* First non-switch parameter is source, second is destination */ if (first != '/') { if (suppliedsource[0] == 0x00) { lstrcpyW(suppliedsource, word); } else if (supplieddestination[0] == 0x00) { lstrcpyW(supplieddestination, word); } else { XCOPY_wprintf(XCOPY_LoadMessage(STRING_INVPARMS)); goto out; } } else { /* Process all the switch options Note: Windows docs say /P prompts when dest is created but tests show it is done for each src file regardless of the destination */ switch (toupper(word[1])) { case 'I': flags |= OPT_ASSUMEDIR; break; case 'S': flags |= OPT_RECURSIVE; break; case 'Q': flags |= OPT_QUIET; break; case 'F': flags |= OPT_FULL; break; case 'L': flags |= OPT_SIMULATE; break; case 'W': flags |= OPT_PAUSE; break; case 'T': flags |= OPT_NOCOPY | OPT_RECURSIVE; break; case 'Y': flags |= OPT_NOPROMPT; break; case 'N': flags |= OPT_SHORTNAME; break; case 'U': flags |= OPT_MUSTEXIST; break; case 'R': flags |= OPT_REPLACEREAD; break; case 'H': flags |= OPT_COPYHIDSYS; break; case 'C': flags |= OPT_IGNOREERRORS; break; case 'P': flags |= OPT_SRCPROMPT; break; case 'A': flags |= OPT_ARCHIVEONLY; break; case 'M': flags |= OPT_ARCHIVEONLY | OPT_REMOVEARCH; break; /* E can be /E or /EXCLUDE */ case 'E': if (CompareStringW(LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT, &word[1], 8, EXCLUDE, -1) == CSTR_EQUAL) { if (XCOPY_ProcessExcludeList(&word[9])) { XCOPY_FailMessage(ERROR_INVALID_PARAMETER); goto out; } else flags |= OPT_EXCLUDELIST; } else flags |= OPT_EMPTYDIR | OPT_RECURSIVE; break; /* D can be /D or /D: */ case 'D': if (word[2]==':' && isdigit(word[3])) { SYSTEMTIME st; WCHAR *pos = &word[3]; BOOL isError = FALSE; memset(&st, 0x00, sizeof(st)); /* Microsoft xcopy's usage message implies that the date * format depends on the locale, but that is false. * It is hardcoded to month-day-year. */ st.wMonth = _wtol(pos); while (*pos && isdigit(*pos)) pos++; if (*pos++ != '-') isError = TRUE; if (!isError) { st.wDay = _wtol(pos); while (*pos && isdigit(*pos)) pos++; if (*pos++ != '-') isError = TRUE; } if (!isError) { st.wYear = _wtol(pos); while (*pos && isdigit(*pos)) pos++; if (st.wYear < 100) st.wYear+=2000; } if (!isError && SystemTimeToFileTime(&st, &dateRange)) { SYSTEMTIME st; WCHAR datestring[32], timestring[32]; flags |= OPT_DATERANGE; /* Debug info: */ FileTimeToSystemTime (&dateRange, &st); GetDateFormatW(0, DATE_SHORTDATE, &st, NULL, datestring, sizeof(datestring)/sizeof(WCHAR)); GetTimeFormatW(0, TIME_NOSECONDS, &st, NULL, timestring, sizeof(timestring)/sizeof(WCHAR)); WINE_TRACE("Date being used is: %s %s\n", wine_dbgstr_w(datestring), wine_dbgstr_w(timestring)); } else { XCOPY_FailMessage(ERROR_INVALID_PARAMETER); goto out; } } else { flags |= OPT_DATENEWER; } break; case '-': if (toupper(word[2])=='Y') flags &= ~OPT_NOPROMPT; break; case '?': XCOPY_wprintf(XCOPY_LoadMessage(STRING_HELP)); rc = RC_HELP; goto out; default: WINE_TRACE("Unhandled parameter '%s'\n", wine_dbgstr_w(word)); XCOPY_wprintf(XCOPY_LoadMessage(STRING_INVPARM), word); goto out; } } word = next; } /* Default the destination if not supplied */ if (supplieddestination[0] == 0x00) lstrcpyW(supplieddestination, wchr_dot); *pflags = flags; rc = RC_OK; out: free(cmdline); return rc; }