int count_tokens( char *s, TOKTYPES *tt ) { int count = 0; char *scp; TOKEN tok; scp = (char *)malloc( strlen( s ) * sizeof(char)); strcpy( scp, s ); if( NULL != tt ) { tt->usr_comment = 0; tt->c_comment = 0; tt->alnum = 0; tt->string = 0; tt-> control = 0; tt->invalid = 0; } tok.actual_token = tok.next_token = scp; while( 1 ) { str_token( &tok ); if( tok.tok_type == TOK_EOS ) break; switch( tok.tok_type ) { case TOK_ALNUM: if( NULL != tt ) tt->alnum++; count++; break; case TOK_USR_COMMENT: if( NULL != tt ) tt->usr_comment++; count++; break; case TOK_C_COMMENT: if( NULL != tt ) tt->c_comment++; count++; break; case TOK_STRING: if( NULL != tt ) tt->string++; count++; break; case TOK_CONTROL: if( NULL != tt ) tt->control++; count++; break; case TOK_INVALID: if( NULL != tt ) tt->invalid++; count++; break; default: break; } } free( scp ); return( count ); }
int main(int argc, const char ** argv) { unsigned x = 0; int argi = 1; predef_info ** predefs = 0; unsigned predef_count = 0; unsigned * i = &first_predef_info.tag; unsigned * e = &last_predef_info.tag; while (i < e) { i += 1; if (*i == 0x67890DEF) { predef_count += 1; predefs = (predef_info**)realloc(predefs,predef_count*sizeof(predef_info*)); predefs[predef_count-1] = (predef_info*)i; } } qsort(predefs,predef_count,sizeof(predef_info*),predef_info_compare); for (argi = 1; argi < argc; ++argi) { const char * exp = argv[argi]; const char * exp_name = str_token(&exp, whitespace); const char * exp_op = str_token(&exp, whitespace); const char * exp_val = str_token(&exp, whitespace); unsigned exp_version = 0; if (*exp_val != 0) { exp = exp_val; const char * exp_val_a = str_token(&exp, dot); const char * exp_val_b = str_token(&exp, dot); const char * exp_val_c = str_token(&exp, dot); exp_version = BOOST_VERSION_NUMBER(atoi(exp_val_a), atoi(exp_val_b),atoi(exp_val_c)); } for (x = 0; x < predef_count; ++x) { if (*exp_op == 0 && predefs[x]->value == 0 && strcmp(exp_name, predefs[x]->name) == 0) { return argi; } else if (*exp_op != 0 && *exp_val != 0 && strcmp(exp_name, predefs[x]->name) == 0) { if (0 == strcmp(">",exp_op) && !(predefs[x]->value > exp_version)) return argi; if (0 == strcmp("<",exp_op) && !(predefs[x]->value < exp_version)) return argi; if (0 == strcmp(">=",exp_op) && !(predefs[x]->value >= exp_version)) return argi; if (0 == strcmp("<=",exp_op) && !(predefs[x]->value <= exp_version)) return argi; if (0 == strcmp("==",exp_op) && !(predefs[x]->value == exp_version)) return argi; if (0 == strcmp("!=",exp_op) && !(predefs[x]->value != exp_version)) return argi; } } } return 0; }
int main( int argc, char **argv ) { int tt, n = 0; char *ptr; TOKEN testtok; printf( "\n\nUTILITY_LIB - DEBUG MODE\n\n" ); if( argc != 2 ) { printf( "usage: utility_lib \"test string\"\n" ); return( -1 ); } printf( "Test string: <%s>\n\n", *(argv+1) ); testtok.actual_token = testtok.next_token = *(argv+1); while( NULL != ( ptr = str_token( &testtok ))) printf( "#%d : length=%4d token_type=%2d token=<%s>\n", ++n, testtok.tok_length, testtok.tok_type, ptr ); return( 0 ); }
static int if_addr_parse(GQueue *q, char *s, struct ifaddrs *ifas) { str name; char *c; sockaddr_t *addr, adv; GQueue addrs = G_QUEUE_INIT; struct intf_config *ifa; /* name */ c = strchr(s, '/'); if (c) { *c++ = 0; str_init(&name, s); s = c; } else str_init(&name, "default"); /* advertised address */ c = strchr(s, '!'); if (c) *c++ = 0; /* address */ addr = g_slice_alloc(sizeof(*addr)); if (!sockaddr_parse_any(addr, s)) { if (is_addr_unspecified(addr)) return -1; g_queue_push_tail(&addrs, addr); } else { // could be an interface name? ilog(LOG_DEBUG, "Could not parse '%s' as network address, checking to see if " "it's an interface", s); for (struct ifaddrs *ifa = ifas; ifa; ifa = ifa->ifa_next) { if (strcmp(ifa->ifa_name, s)) continue; if (!(ifa->ifa_flags & IFF_UP)) continue; if (!ifa->ifa_addr) continue; if (ifa->ifa_addr->sa_family == AF_INET) { struct sockaddr_in *sin = (void *) ifa->ifa_addr; addr->family = __get_socket_family_enum(SF_IP4); addr->u.ipv4 = sin->sin_addr; } else if (ifa->ifa_addr->sa_family == AF_INET6) { struct sockaddr_in6 *sin = (void *) ifa->ifa_addr; if (sin->sin6_scope_id) continue; // link-local addr->family = __get_socket_family_enum(SF_IP6); addr->u.ipv6 = sin->sin6_addr; } else continue; // got one ilog(LOG_DEBUG, "Determined address %s for interface '%s'", sockaddr_print_buf(addr), s); g_queue_push_tail(&addrs, addr); addr = g_slice_alloc(sizeof(*addr)); } // free last unused entry g_slice_free1(sizeof(*addr), addr); } if (!addrs.length) // nothing found return -1; ZERO(adv); if (c) { if (sockaddr_parse_any(&adv, c)) return -1; if (is_addr_unspecified(&adv)) return -1; } while ((addr = g_queue_pop_head(&addrs))) { ifa = g_slice_alloc0(sizeof(*ifa)); ifa->name = name; ifa->local_address.addr = *addr; ifa->local_address.type = socktype_udp; ifa->advertised_address.addr = adv; if (is_addr_unspecified(&ifa->advertised_address.addr)) ifa->advertised_address.addr = *addr; ifa->advertised_address.type = ifa->local_address.type; ifa->port_min = rtpe_config.port_min; ifa->port_max = rtpe_config.port_max; // handle "base:suffix" separation for round-robin selection ifa->name_rr_spec = ifa->name; str_token(&ifa->name_base, &ifa->name_rr_spec, ':'); // sets name_rr_spec to null string if no ':' found g_queue_push_tail(q, ifa); g_slice_free1(sizeof(*addr), addr); } return 0; }
/* Event handler for EV_MEM_SYSTEM_COMMAND. * The event data is a string of type 'char *' that needs to be deallocated * after processing this event. */ void mem_system_command_handler(int event, void *data) { struct list_t *token_list; char *command_line = data; char command[MAX_STRING_SIZE]; /* Get command */ str_token(command, sizeof command, command_line, 0, " "); if (!command[0]) fatal("%s: invalid command syntax.\n\t> %s", __FUNCTION__, command_line); /* Commands that need to be processed at the end of the simulation * are ignored here. These are command prefixed with 'CheckXXX'. */ if (!strncasecmp(command, "Check", 5)) { esim_schedule_end_event(EV_MEM_SYSTEM_END_COMMAND, data); return; } /* Split command in tokens, skip command */ token_list = str_token_list_create(command_line, " "); assert(list_count(token_list)); str_token_list_shift(token_list); /* Command 'SetBlock' */ if (!strcasecmp(command, "SetBlock")) { struct mod_t *mod; int set; int way; int tag; int set_check; int tag_check; int state; mod = mem_system_command_get_mod(token_list, command_line); mem_system_command_get_set_way(token_list, command_line, mod, &set, &way); tag = mem_system_command_get_hex(token_list, command_line); state = mem_system_command_get_state(token_list, command_line); mem_system_command_end(token_list, command_line); /* Check that module serves address */ if (!mod_serves_address(mod, tag)) fatal("%s: %s: module does not serve address 0x%x.\n\t> %s", __FUNCTION__, mod->name, tag, command_line); /* Check that tag goes to specified set */ mod_find_block(mod, tag, &set_check, NULL, &tag_check, NULL); if (set != set_check) fatal("%s: %s: tag 0x%x belongs to set %d.\n\t> %s", __FUNCTION__, mod->name, tag, set_check, command_line); if (tag != tag_check) fatal("%s: %s: tag should be multiple of block size.\n\t> %s", __FUNCTION__, mod->name, command_line); /* Set tag */ cache_set_block(mod->cache, set, way, tag, state); } /* Command 'SetOwner' */ else if (!strcasecmp(command, "SetOwner")) { struct mod_t *mod; struct mod_t *owner; int set; int way; int sub_block; int owner_index; /* Get fields */ mod = mem_system_command_get_mod(token_list, command_line); mem_system_command_get_set_way(token_list, command_line, mod, &set, &way); sub_block = mem_system_command_get_sub_block(token_list, command_line, mod, set, way); owner = mem_system_command_get_mod(token_list, command_line); mem_system_command_end(token_list, command_line); /* Check that owner is an immediate higher-level module */ if (owner) { if (owner->low_net != mod->high_net || !owner->low_net) fatal("%s: %s is not a higher-level module of %s.\n\t> %s", __FUNCTION__, owner->name, mod->name, command_line); } /* Set owner */ owner_index = owner ? owner->low_net_node->index : -1; dir_entry_set_owner(mod->dir, set, way, sub_block, owner_index); } /* Command 'SetSharers' */ else if (!strcasecmp(command, "SetSharers")) { struct mod_t *mod; struct mod_t *sharer; int set; int way; int sub_block; /* Get first fields */ mod = mem_system_command_get_mod(token_list, command_line); mem_system_command_get_set_way(token_list, command_line, mod, &set, &way); sub_block = mem_system_command_get_sub_block(token_list, command_line, mod, set, way); /* Get sharers */ mem_system_command_expect(token_list, command_line); dir_entry_clear_all_sharers(mod->dir, set, way, sub_block); while (list_count(token_list)) { /* Get sharer */ sharer = mem_system_command_get_mod(token_list, command_line); if (!sharer) continue; /* Check that sharer is an immediate higher-level module */ if (sharer->low_net != mod->high_net || !sharer->low_net) fatal("%s: %s is not a higher-level module of %s.\n\t> %s", __FUNCTION__, sharer->name, mod->name, command_line); /* Set sharer */ dir_entry_set_sharer(mod->dir, set, way, sub_block, sharer->low_net_node->index); } } /* Command 'Access' */ else if (!strcasecmp(command, "Access")) { struct mod_t *mod; enum mod_access_kind_t access_kind; unsigned int addr; long long cycle; /* Read fields */ mod = mem_system_command_get_mod(token_list, command_line); cycle = mem_system_command_get_cycle(token_list, command_line); access_kind = mem_system_command_get_mod_access(token_list, command_line); addr = mem_system_command_get_hex(token_list, command_line); /* If command is scheduled for later, exit */ if (cycle > esim_cycle) { str_token_list_free(token_list); esim_schedule_event(EV_MEM_SYSTEM_COMMAND, data, cycle - esim_cycle); return; } /* Access module */ mod_access(mod, access_kind, addr, NULL, NULL, NULL, NULL); } /* Command not supported */ else fatal("%s: %s: invalid command.\n\t> %s", __FUNCTION__, command, command_line); /* Free command */ free(command_line); str_token_list_free(token_list); }
int wpas_mbo_update_non_pref_chan(struct wpa_supplicant *wpa_s, const char *non_pref_chan) { char *cmd, *token, *context = NULL; struct wpa_mbo_non_pref_channel *chans = NULL, *tmp_chans; size_t num = 0, size = 0; unsigned i; wpa_printf(MSG_DEBUG, "MBO: Update non-preferred channels, non_pref_chan=%s", non_pref_chan ? non_pref_chan : "N/A"); /* * The shortest channel configuration is 10 characters - commas, 3 * colons, and 4 values that one of them (oper_class) is 2 digits or * more. */ if (!non_pref_chan || os_strlen(non_pref_chan) < 10) goto update; cmd = os_strdup(non_pref_chan); if (!cmd) return -1; while ((token = str_token(cmd, " ", &context))) { struct wpa_mbo_non_pref_channel *chan; int ret; unsigned int _oper_class; unsigned int _chan; unsigned int _preference; unsigned int _reason; if (num == size) { size = size ? size * 2 : 1; tmp_chans = os_realloc_array(chans, size, sizeof(*chans)); if (!tmp_chans) { wpa_printf(MSG_ERROR, "Couldn't reallocate non_pref_chan"); goto fail; } chans = tmp_chans; } chan = &chans[num]; ret = sscanf(token, "%u:%u:%u:%u", &_oper_class, &_chan, &_preference, &_reason); if (ret != 4 || _oper_class > 255 || _chan > 255 || _preference > 255 || _reason > 65535 ) { wpa_printf(MSG_ERROR, "Invalid non-pref chan input %s", token); goto fail; } chan->oper_class = _oper_class; chan->chan = _chan; chan->preference = _preference; chan->reason = _reason; if (wpas_mbo_validate_non_pref_chan(chan->oper_class, chan->chan, chan->reason)) { wpa_printf(MSG_ERROR, "Invalid non_pref_chan: oper class %d chan %d reason %d", chan->oper_class, chan->chan, chan->reason); goto fail; } for (i = 0; i < num; i++) if (wpa_non_pref_chan_is_eq(chan, &chans[i])) break; if (i != num) { wpa_printf(MSG_ERROR, "oper class %d chan %d is duplicated", chan->oper_class, chan->chan); goto fail; } num++; } os_free(cmd); if (chans) { qsort(chans, num, sizeof(struct wpa_mbo_non_pref_channel), wpa_non_pref_chan_cmp); } update: os_free(wpa_s->non_pref_chan); wpa_s->non_pref_chan = chans; wpa_s->non_pref_chan_num = num; wpas_mbo_non_pref_chan_changed(wpa_s); return 0; fail: os_free(chans); os_free(cmd); return -1; }