/* load_txt_font: * Loads a scripted font. */ FONT *load_txt_font(AL_CONST char *filename, RGB *pal, void *param) { char buf[1024], *font_str, *start_str = 0, *end_str = 0; char font_filename[1024]; FONT *f, *f2, *f3, *f4; PACKFILE *pack; int begin, end, glyph_pos=32; pack = pack_fopen(filename, F_READ); if (!pack) return NULL; f = f2 = f3 = f4 = NULL; while(pack_fgets(buf, sizeof(buf)-1, pack)) { font_str = strtok(buf, " \t"); if (font_str) start_str = strtok(0, " \t"); if (start_str) end_str = strtok(0, " \t"); if (!font_str || !start_str) { if (f) destroy_font(f); if (f2) destroy_font(f2); pack_fclose(pack); return NULL; } if(font_str[0] == '-') font_str[0] = '\0'; begin = strtol(start_str, 0, 0); if (end_str) end = strtol(end_str, 0, 0); else end = -1; if(begin <= 0 || (end > 0 && end < begin)) { if (f) destroy_font(f); if (f2) destroy_font(f2); pack_fclose(pack); return NULL; } /* Load the font that needs to be merged with the current font */ if (font_str[0]) { if (f2) destroy_font(f2); if (exists(font_str)) { f2 = load_font(font_str, pal, param); } else if (is_relative_filename(font_str)) { replace_filename(font_filename, filename, font_str, sizeof(font_filename)); f2 = load_font(font_filename, pal, param); } else { f2 = NULL; } if (f2) glyph_pos=get_font_range_begin(f2, -1); } if (!f2) { if (f) destroy_font(f); pack_fclose(pack); return NULL; } if (end == -1) end = begin + get_font_range_end(f2,-1) - glyph_pos; /* transpose the font to the range given in the .txt file */ f4=extract_font_range(f2,glyph_pos,glyph_pos + (end - begin)); if (f4 && (begin != glyph_pos)) { transpose_font(f4, begin - glyph_pos); } glyph_pos += (end - begin) + 1; /* FIXME: More efficient way than to repeatedely merge into a new font? */ if (f && f4) { f3 = f; f = merge_fonts(f4, f3); destroy_font(f4); destroy_font(f3); } else { f = f4; } f3=f4=NULL; } if (f2) destroy_font(f2); pack_fclose(pack); return f; }
int parseSection(char *s, int *x0, int *x1, int *y0, int *y1, int *block){ int itype=0, got=0; double tx0=0, tx1=0, ty0=0, ty1=0; double dim1, dim2, cen1, cen2; char s1[SLEN], s2[SLEN], s3[SLEN], s4[SLEN], s5[SLEN]; char *t; /* look for different ways of specifying the section -- order counts! */ if(sscanf(s, "%32[-0-9.dDeE] : %32[-0-9.dDeE] , %32[-0-9.dDeE] : %32[-0-9.dDeE] , %32[0-9]", s1, s2, s3, s4, s5) == 5){ tx0 = atof(s1); tx1 = atof(s2); ty0 = atof(s3); ty1 = atof(s4); *block = MAX(1, atof(s5)); got = 1; } else if(sscanf(s, "%32[-0-9.dDeE] : %32[-0-9.dDeE] , %32[-0-9.dDeE] : %32[-0-9.dDeE]", s1, s2, s3, s4) == 4){ tx0 = atof(s1); tx1 = atof(s2); ty0 = atof(s3); ty1 = atof(s4); *block = 1; got = 1; } else if(sscanf(s, "%32[-0-9.dDeE] : %32[-0-9.dDeE] , %32[0-9as]", s1, s2, s3) == 3){ tx0 = atof(s1); tx1 = atof(s2); ty0 = tx0; ty1 = tx1; *block = MAX(1, atof(s3)); got = 1; } else if(sscanf(s, "%32[-0-9.dDeE] : %32[-0-9.dDeE]", s1, s2) == 2){ tx0 = atof(s1); tx1 = atof(s2); ty0 = tx0; ty1 = tx1; *block = 1; got = 1; } else if(sscanf(s, "%32[0-9.dDeE] @ %32[-0-9.dDeE] , %32[0-9.dDeE] @ %32[-0-9.dDeE] , %32[0-9]", s1, s2, s3, s4, s5) == 5){ dim1 = atof(s1); cen1 = atof(s2); dim2 = atof(s3); cen2 = atof(s4); *block = MAX(1, strtol(s5, &t, 0)); itype = 1; got = 1; } else if(sscanf(s, "%32[0-9.dDeE] @ %32[-0-9.dDeE] , %32[0-9.dDeE] @ %32[-0-9.dDeE]", s1, s2, s3, s4) == 4){ dim1 = atof(s1); cen1 = atof(s2); dim2 = atof(s3); cen2 = atof(s4); *block = 1; itype = 1; got = 1; } else if(sscanf(s, "%32[0-9.dDeE] @ %32[-0-9.dDeE] , %32[0-9]", s1, s2, s3) == 3){ dim1 = atof(s1); cen1 = atof(s2); dim2 = dim1; cen2 = cen1; *block = MAX(1, strtol(s3, &t, 0)); itype = 1; got = 1; } else if(sscanf(s, "%32[0-9.dDeE] @ %32[-0-9.dDeE]", s1, s2) == 2){ dim1 = atof(s1); cen1 = atof(s2); dim2 = dim1; cen2 = cen1; itype = 1; got = 1; } /* if we are processing dim@center, we need to calculate section values */ if( itype ){ tx0 = cen1 - ((dim1+1)/2) + 1; ty0 = cen2 - ((dim2+1)/2) + 1; /* this method maintains the center and changes the dimensions */ /* Frank, Eric, and John all prefer this method, so that the user gets the center he asked for, even if the image is reduced */ tx1 = cen1 + (dim1/2); ty1 = cen2 + (dim2/2); } /* now we can integerize and set the output values */ *x0 = (int)tx0; *x1 = (int)tx1; *y0 = (int)ty0; *y1 = (int)ty1; return got; }
/* * Read and process poll commands * Return: -1 for quit command * 0 otherwise */ int process_args(int cmd_argc, char **cmd_argv, Poll **poll_list_ptr) { // some commands need the poll_list head and others // require the address of that head Poll *poll_list = *poll_list_ptr; if (cmd_argc <= 0) { return 0; } else if (strcmp(cmd_argv[0], "quit") == 0 && cmd_argc == 1) { return -1; } else if (strcmp(cmd_argv[0], "add_poll") == 0 && cmd_argc == 3) { if (insert_new_poll(cmd_argv[1], strtol(cmd_argv[2], NULL, 10), poll_list_ptr) == 1) { error("Poll by this name already exists"); } } else if (strcmp(cmd_argv[0], "list_polls") == 0 && cmd_argc == 1) { print_polls(poll_list); } else if (strcmp(cmd_argv[0], "configure_poll") == 0 && cmd_argc >= 3) { int label_count = cmd_argc - 2; int result = configure_poll(cmd_argv[1], &cmd_argv[2], label_count, poll_list); if (result == 1) { error("Poll by this name does not exist"); } else if (result == 2) { error("Wrong number of slot labels provided for this poll\n"); } } else if (strcmp(cmd_argv[0], "add_participant") == 0 && cmd_argc == 4) { int return_code = add_participant(cmd_argv[1], cmd_argv[2], poll_list, cmd_argv[3]); if (return_code == 1) { error("Poll by this name does not exist"); } else if (return_code == 2) { error("This Poll already has a participant by this name"); } else if (return_code == 3) { error("Availability string is wrong size for this poll"); } } else if (strcmp(cmd_argv[0], "add_comment") == 0 && cmd_argc >= 4) { // first determine how long a string we need int space_needed = 0; int i; for (i=3; i<cmd_argc; i++) { space_needed += strlen(cmd_argv[i]) + 1; } // allocate the space char *comment = malloc(space_needed); if (comment == NULL) { perror("malloc"); exit(1); } // copy in the bits to make a single string strcpy(comment, cmd_argv[3]); for (i=4; i<cmd_argc; i++) { strcat(comment, " "); strcat(comment, cmd_argv[i]); } int return_code = add_comment(cmd_argv[1], cmd_argv[2], comment, poll_list); // comment was only used as parameter so we are finished with it now free(comment); if (return_code == 1) { error("There is no poll with this name"); } else if (return_code == 2) { error("There is no participant by this name in this poll"); } } else if (strcmp(cmd_argv[0], "update_availability") == 0 && cmd_argc == 4) { int return_code = update_availability(cmd_argv[1], cmd_argv[2], cmd_argv[3], poll_list); if (return_code == 1) { error("There is no poll with this name"); } else if (return_code == 2) { error("There is no participant by this name in this poll"); } else if (return_code == 3) { error("The length of the provided availability does not match" "number of slots in this poll"); } } else if (strcmp(cmd_argv[0], "delete_poll") == 0 && cmd_argc == 2) { if (delete_poll(cmd_argv[1], poll_list_ptr) == 1) { error("No poll by this name exists"); } } else if (strcmp(cmd_argv[0], "print_poll_info") == 0 && cmd_argc == 2) { if (print_poll_info(cmd_argv[1], poll_list) == 1) { error("No poll by this name exists"); } } else { error("Incorrect syntax"); } return 0; }
/** * Parse the target part of a rule. */ static int c2_parse_target(session_t *ps, const char *pattern, int offset, c2_ptr_t *presult) { // Initialize leaf presult->isbranch = false; presult->l = malloc(sizeof(c2_l_t)); if (!presult->l) c2_error("Failed to allocate memory for new leaf."); c2_l_t * const pleaf = presult->l; memcpy(pleaf, &leaf_def, sizeof(c2_l_t)); // Parse negation marks while ('!' == pattern[offset]) { pleaf->neg = !pleaf->neg; ++offset; C2H_SKIP_SPACES(); } // Copy target name out unsigned tgtlen = 0; for (; pattern[offset] && (isalnum(pattern[offset]) || '_' == pattern[offset]); ++offset) { ++tgtlen; } if (!tgtlen) c2_error("Empty target."); pleaf->tgt = mstrncpy(&pattern[offset - tgtlen], tgtlen); // Check for predefined targets for (unsigned i = 1; i < sizeof(C2_PREDEFS) / sizeof(C2_PREDEFS[0]); ++i) { if (!strcmp(C2_PREDEFS[i].name, pleaf->tgt)) { pleaf->predef = i; pleaf->type = C2_PREDEFS[i].type; pleaf->format = C2_PREDEFS[i].format; break; } } // Alias for predefined targets if (!pleaf->predef) { #define TGTFILL(pdefid) \ (pleaf->predef = pdefid, \ pleaf->type = C2_PREDEFS[pdefid].type, \ pleaf->format = C2_PREDEFS[pdefid].format) // if (!strcmp("WM_NAME", tgt) || !strcmp("_NET_WM_NAME", tgt)) // TGTFILL(C2_L_PNAME); #undef TGTFILL // Alias for custom properties #define TGTFILL(target, type, format) \ (pleaf->target = mstrcpy(target), \ pleaf->type = type, \ pleaf->format = format) // if (!strcmp("SOME_ALIAS")) // TGTFILL("ALIAS_TEXT", C2_L_TSTRING, 32); #undef TGTFILL } C2H_SKIP_SPACES(); // Parse target-on-frame flag if ('@' == pattern[offset]) { pleaf->tgt_onframe = true; ++offset; C2H_SKIP_SPACES(); } // Parse index if ('[' == pattern[offset]) { offset++; C2H_SKIP_SPACES(); int index = -1; char *endptr = NULL; index = strtol(pattern + offset, &endptr, 0); if (!endptr || pattern + offset == endptr) c2_error("No index number found after bracket."); if (index < 0) c2_error("Index number invalid."); if (pleaf->predef) c2_error("Predefined targets can't have index."); pleaf->index = index; offset = endptr - pattern; C2H_SKIP_SPACES(); if (']' != pattern[offset]) c2_error("Index end marker not found."); ++offset; C2H_SKIP_SPACES(); } // Parse target type and format if (':' == pattern[offset]) { ++offset; C2H_SKIP_SPACES(); // Look for format bool hasformat = false; int format = 0; { char *endptr = NULL; format = strtol(pattern + offset, &endptr, 0); assert(endptr); if ((hasformat = (endptr && endptr != pattern + offset))) offset = endptr - pattern; C2H_SKIP_SPACES(); } // Look for type enum c2_l_type type = C2_L_TUNDEFINED; { switch (pattern[offset]) { case 'w': type = C2_L_TWINDOW; break; case 'd': type = C2_L_TDRAWABLE; break; case 'c': type = C2_L_TCARDINAL; break; case 's': type = C2_L_TSTRING; break; case 'a': type = C2_L_TATOM; break; default: c2_error("Invalid type character."); } if (type) { if (pleaf->predef) { printf_errf("(): Warning: Type specified for a default target will be ignored."); } else { if (pleaf->type && type != pleaf->type) printf_errf("(): Warning: Default type overridden on target."); pleaf->type = type; } } offset++; C2H_SKIP_SPACES(); } // Default format if (!pleaf->format) { switch (pleaf->type) { case C2_L_TWINDOW: case C2_L_TDRAWABLE: case C2_L_TATOM: pleaf->format = 32; break; case C2_L_TSTRING: pleaf->format = 8; break; default: break; } } // Write format if (hasformat) { if (pleaf->predef) printf_errf("(): Warning: Format \"%d\" specified on a default target will be ignored.", format); else if (C2_L_TSTRING == pleaf->type) printf_errf("(): Warning: Format \"%d\" specified on a string target will be ignored.", format); else { if (pleaf->format && pleaf->format != format) printf_err("Warning: Default format %d overridden on target.", pleaf->format); pleaf->format = format; } } } if (!pleaf->type) c2_error("Target type cannot be determined."); // if (!pleaf->predef && !pleaf->format && C2_L_TSTRING != pleaf->type) // c2_error("Target format cannot be determined."); if (pleaf->format && 8 != pleaf->format && 16 != pleaf->format && 32 != pleaf->format) c2_error("Invalid format."); return offset; }
int main(int argc, char **argv) { struct sockaddr sa; char host[128]; struct aftype *ap; struct hwtype *hw; struct ifreq ifr; int goterr = 0, didnetmask = 0; char **spp; int fd; #if HAVE_AFINET6 extern struct aftype inet6_aftype; struct sockaddr_in6 sa6; struct in6_ifreq ifr6; unsigned long prefix_len; char *cp; #endif #if I18N bindtextdomain("net-tools", "/usr/share/locale"); textdomain("net-tools"); #endif /* Create a channel to the NET kernel. */ if ((skfd = sockets_open(0)) < 0) { perror("socket"); exit(1); } /* Find any options. */ argc--; argv++; while (argc && *argv[0] == '-') { if (!strcmp(*argv, "-a")) opt_a = 1; if (!strcmp(*argv, "-v")) opt_v = 1; if (!strcmp(*argv, "-V") || !strcmp(*argv, "-version") || !strcmp(*argv, "--version")) version(); if (!strcmp(*argv, "-?") || !strcmp(*argv, "-h") || !strcmp(*argv, "-help") || !strcmp(*argv, "--help")) usage(); argv++; argc--; } /* Do we have to show the current setup? */ if (argc == 0) { int err = if_print((char *) NULL); (void) close(skfd); exit(err < 0); } /* No. Fetch the interface name. */ spp = argv; safe_strncpy(ifr.ifr_name, *spp++, IFNAMSIZ); if (*spp == (char *) NULL) { int err = if_print(ifr.ifr_name); (void) close(skfd); exit(err < 0); } /* The next argument is either an address family name, or an option. */ if ((ap = get_aftype(*spp)) == NULL) ap = get_aftype(DFLT_AF); else { /* XXX: should print the current setup if no args left, but only for this family */ spp++; addr_family = ap->af; } if (sockets_open(addr_family) < 0) { perror("family socket"); exit(1); } /* Process the remaining arguments. */ while (*spp != (char *) NULL) { if (!strcmp(*spp, "arp")) { goterr |= clr_flag(ifr.ifr_name, IFF_NOARP); spp++; continue; } if (!strcmp(*spp, "-arp")) { goterr |= set_flag(ifr.ifr_name, IFF_NOARP); spp++; continue; } #ifdef IFF_PORTSEL if (!strcmp(*spp, "media") || !strcmp(*spp, "port")) { if (*++spp == NULL) usage(); if (!strcasecmp(*spp, "auto")) { goterr |= set_flag(ifr.ifr_name, IFF_AUTOMEDIA); } else { int i, j, newport; char *endp; newport = strtol(*spp, &endp, 10); if (*endp != 0) { newport = -1; for (i = 0; if_port_text[i][0] && newport == -1; i++) { for (j = 0; if_port_text[i][j]; j++) { if (!strcasecmp(*spp, if_port_text[i][j])) { newport = i; break; } } } } spp++; if (newport == -1) { fprintf(stderr, _("Unknown media type.\n")); goterr = 1; } else { if (ioctl(skfd, SIOCGIFMAP, &ifr) < 0) { goterr = 1; continue; } ifr.ifr_map.port = newport; if (ioctl(skfd, SIOCSIFMAP, &ifr) < 0) { perror("SIOCSIFMAP"); goterr = 1; } } } continue; } #endif if (!strcmp(*spp, "trailers")) { goterr |= clr_flag(ifr.ifr_name, IFF_NOTRAILERS); spp++; continue; } if (!strcmp(*spp, "-trailers")) { goterr |= set_flag(ifr.ifr_name, IFF_NOTRAILERS); spp++; continue; } if (!strcmp(*spp, "promisc")) { goterr |= set_flag(ifr.ifr_name, IFF_PROMISC); spp++; continue; } if (!strcmp(*spp, "-promisc")) { goterr |= clr_flag(ifr.ifr_name, IFF_PROMISC); spp++; continue; } if (!strcmp(*spp, "multicast")) { goterr |= set_flag(ifr.ifr_name, IFF_MULTICAST); spp++; continue; } if (!strcmp(*spp, "-multicast")) { goterr |= clr_flag(ifr.ifr_name, IFF_MULTICAST); spp++; continue; } if (!strcmp(*spp, "allmulti")) { goterr |= set_flag(ifr.ifr_name, IFF_ALLMULTI); spp++; continue; } if (!strcmp(*spp, "-allmulti")) { goterr |= clr_flag(ifr.ifr_name, IFF_ALLMULTI); spp++; continue; } if (!strcmp(*spp, "up")) { goterr |= set_flag(ifr.ifr_name, (IFF_UP | IFF_RUNNING)); spp++; continue; } if (!strcmp(*spp, "down")) { goterr |= clr_flag(ifr.ifr_name, IFF_UP); spp++; continue; } #ifdef HAVE_DYNAMIC if (!strcmp(*spp, "dynamic")) { goterr |= set_flag(ifr.ifr_name, IFF_DYNAMIC); spp++; continue; } if (!strcmp(*spp, "-dynamic")) { goterr |= clr_flag(ifr.ifr_name, IFF_DYNAMIC); spp++; continue; } #endif if (!strcmp(*spp, "metric")) { if (*++spp == NULL) usage(); ifr.ifr_metric = atoi(*spp); if (ioctl(skfd, SIOCSIFMETRIC, &ifr) < 0) { fprintf(stderr, "SIOCSIFMETRIC: %s\n", strerror(errno)); goterr = 1; } spp++; continue; } if (!strcmp(*spp, "mtu")) { if (*++spp == NULL) usage(); ifr.ifr_mtu = atoi(*spp); if (ioctl(skfd, SIOCSIFMTU, &ifr) < 0) { fprintf(stderr, "SIOCSIFMTU: %s\n", strerror(errno)); goterr = 1; } spp++; continue; } #ifdef SIOCSKEEPALIVE if (!strcmp(*spp, "keepalive")) { if (*++spp == NULL) usage(); ifr.ifr_data = (caddr_t) atoi(*spp); if (ioctl(skfd, SIOCSKEEPALIVE, &ifr) < 0) { fprintf(stderr, "SIOCSKEEPALIVE: %s\n", strerror(errno)); goterr = 1; } spp++; continue; } #endif #ifdef SIOCSOUTFILL if (!strcmp(*spp, "outfill")) { if (*++spp == NULL) usage(); ifr.ifr_data = (caddr_t) atoi(*spp); if (ioctl(skfd, SIOCSOUTFILL, &ifr) < 0) { fprintf(stderr, "SIOCSOUTFILL: %s\n", strerror(errno)); goterr = 1; } spp++; continue; } #endif if (!strcmp(*spp, "-broadcast")) { goterr |= clr_flag(ifr.ifr_name, IFF_BROADCAST); spp++; continue; } if (!strcmp(*spp, "broadcast")) { if (*++spp != NULL) { safe_strncpy(host, *spp, (sizeof host)); if (ap->input(0, host, &sa) < 0) { ap->herror(host); goterr = 1; spp++; continue; } memcpy((char *) &ifr.ifr_broadaddr, (char *) &sa, sizeof(struct sockaddr)); if (ioctl(ap->fd, SIOCSIFBRDADDR, &ifr) < 0) { fprintf(stderr, "SIOCSIFBRDADDR: %s\n", strerror(errno)); goterr = 1; } spp++; } goterr |= set_flag(ifr.ifr_name, IFF_BROADCAST); continue; } if (!strcmp(*spp, "dstaddr")) { if (*++spp == NULL) usage(); safe_strncpy(host, *spp, (sizeof host)); if (ap->input(0, host, &sa) < 0) { ap->herror(host); goterr = 1; spp++; continue; } memcpy((char *) &ifr.ifr_dstaddr, (char *) &sa, sizeof(struct sockaddr)); if (ioctl(ap->fd, SIOCSIFDSTADDR, &ifr) < 0) { fprintf(stderr, "SIOCSIFDSTADDR: %s\n", strerror(errno)); goterr = 1; } spp++; continue; } if (!strcmp(*spp, "netmask")) { if (*++spp == NULL || didnetmask) usage(); safe_strncpy(host, *spp, (sizeof host)); if (ap->input(0, host, &sa) < 0) { ap->herror(host); goterr = 1; spp++; continue; } didnetmask++; goterr = set_netmask(ap->fd, &ifr, &sa); spp++; continue; } #ifdef HAVE_TXQUEUELEN if (!strcmp(*spp, "txqueuelen")) { if (*++spp == NULL) usage(); ifr.ifr_qlen = strtoul(*spp, NULL, 0); if (ioctl(skfd, SIOCSIFTXQLEN, &ifr) < 0) { fprintf(stderr, "SIOCSIFTXQLEN: %s\n", strerror(errno)); goterr = 1; } spp++; continue; } #endif if (!strcmp(*spp, "mem_start")) { if (*++spp == NULL) usage(); if (ioctl(skfd, SIOCGIFMAP, &ifr) < 0) { goterr = 1; continue; } ifr.ifr_map.mem_start = strtoul(*spp, NULL, 0); if (ioctl(skfd, SIOCSIFMAP, &ifr) < 0) { fprintf(stderr, "SIOCSIFMAP: %s\n", strerror(errno)); goterr = 1; } spp++; continue; } if (!strcmp(*spp, "io_addr")) { if (*++spp == NULL) usage(); if (ioctl(skfd, SIOCGIFMAP, &ifr) < 0) { goterr = 1; continue; } ifr.ifr_map.base_addr = strtol(*spp, NULL, 0); if (ioctl(skfd, SIOCSIFMAP, &ifr) < 0) { fprintf(stderr, "SIOCSIFMAP: %s\n", strerror(errno)); goterr = 1; } spp++; continue; } if (!strcmp(*spp, "irq")) { if (*++spp == NULL) usage(); if (ioctl(skfd, SIOCGIFMAP, &ifr) < 0) { goterr = 1; continue; } ifr.ifr_map.irq = atoi(*spp); if (ioctl(skfd, SIOCSIFMAP, &ifr) < 0) { fprintf(stderr, "SIOCSIFMAP: %s\n", strerror(errno)); goterr = 1; } spp++; continue; } if (!strcmp(*spp, "-pointopoint")) { goterr |= clr_flag(ifr.ifr_name, IFF_POINTOPOINT); spp++; continue; } if (!strcmp(*spp, "pointopoint")) { if (*(spp + 1) != NULL) { spp++; safe_strncpy(host, *spp, (sizeof host)); if (ap->input(0, host, &sa)) { ap->herror(host); goterr = 1; spp++; continue; } memcpy((char *) &ifr.ifr_dstaddr, (char *) &sa, sizeof(struct sockaddr)); if (ioctl(ap->fd, SIOCSIFDSTADDR, &ifr) < 0) { fprintf(stderr, "SIOCSIFDSTADDR: %s\n", strerror(errno)); goterr = 1; } } goterr |= set_flag(ifr.ifr_name, IFF_POINTOPOINT); spp++; continue; }; if (!strcmp(*spp, "hw")) { if (*++spp == NULL) usage(); if ((hw = get_hwtype(*spp)) == NULL) usage(); if (*++spp == NULL) usage(); safe_strncpy(host, *spp, (sizeof host)); if (hw->input(host, &sa) < 0) { fprintf(stderr, _("%s: invalid %s address.\n"), host, hw->name); goterr = 1; spp++; continue; } memcpy((char *) &ifr.ifr_hwaddr, (char *) &sa, sizeof(struct sockaddr)); if (ioctl(skfd, SIOCSIFHWADDR, &ifr) < 0) { fprintf(stderr, "SIOCSIFHWADDR: %s\n", strerror(errno)); goterr = 1; } spp++; continue; } #if HAVE_AFINET6 if (!strcmp(*spp, "add")) { if (*++spp == NULL) usage(); if ((cp = strchr(*spp, '/'))) { prefix_len = atol(cp + 1); if ((prefix_len < 0) || (prefix_len > 128)) usage(); *cp = 0; } else { prefix_len = 0; } safe_strncpy(host, *spp, (sizeof host)); if (inet6_aftype.input(1, host, (struct sockaddr *) &sa6) < 0) { inet6_aftype.herror(host); goterr = 1; spp++; continue; } memcpy((char *) &ifr6.ifr6_addr, (char *) &sa6.sin6_addr, sizeof(struct in6_addr)); fd = get_socket_for_af(AF_INET6); if (fd < 0) { fprintf(stderr, _("No support for INET6 on this system.\n")); goterr = 1; spp++; continue; } if (ioctl(fd, SIOGIFINDEX, &ifr) < 0) { perror("SIOGIFINDEX"); goterr = 1; spp++; continue; } ifr6.ifr6_ifindex = ifr.ifr_ifindex; ifr6.ifr6_prefixlen = prefix_len; if (ioctl(fd, SIOCSIFADDR, &ifr6) < 0) { perror("SIOCSIFADDR"); goterr = 1; } spp++; continue; } if (!strcmp(*spp, "del")) { if (*++spp == NULL) usage(); if ((cp = strchr(*spp, '/'))) { prefix_len = atol(cp + 1); if ((prefix_len < 0) || (prefix_len > 128)) usage(); *cp = 0; } else { prefix_len = 0; } safe_strncpy(host, *spp, (sizeof host)); if (inet6_aftype.input(1, host, (struct sockaddr *) &sa6) < 0) { inet6_aftype.herror(host); goterr = 1; spp++; continue; } memcpy((char *) &ifr6.ifr6_addr, (char *) &sa6.sin6_addr, sizeof(struct in6_addr)); fd = get_socket_for_af(AF_INET6); if (fd < 0) { fprintf(stderr, _("No support for INET6 on this system.\n")); goterr = 1; spp++; continue; } if (ioctl(fd, SIOGIFINDEX, &ifr) < 0) { perror("SIOGIFINDEX"); goterr = 1; spp++; continue; } ifr6.ifr6_ifindex = ifr.ifr_ifindex; ifr6.ifr6_prefixlen = prefix_len; #ifdef SIOCDIFADDR if (ioctl(fd, SIOCDIFADDR, &ifr6) < 0) { fprintf(stderr, "SIOCDIFADDR: %s\n", strerror(errno)); goterr = 1; } #else fprintf(stderr, _("Address deletion not supported on this system.\n")); #endif spp++; continue; } if (!strcmp(*spp, "tunnel")) { if (*++spp == NULL) usage(); if ((cp = strchr(*spp, '/'))) { prefix_len = atol(cp + 1); if ((prefix_len < 0) || (prefix_len > 128)) usage(); *cp = 0; } else { prefix_len = 0; } safe_strncpy(host, *spp, (sizeof host)); if (inet6_aftype.input(1, host, (struct sockaddr *) &sa6) < 0) { inet6_aftype.herror(host); goterr = 1; spp++; continue; } memcpy((char *) &ifr6.ifr6_addr, (char *) &sa6.sin6_addr, sizeof(struct in6_addr)); fd = get_socket_for_af(AF_INET6); if (fd < 0) { fprintf(stderr, _("No support for INET6 on this system.\n")); goterr = 1; spp++; continue; } if (ioctl(fd, SIOGIFINDEX, &ifr) < 0) { perror("SIOGIFINDEX"); goterr = 1; spp++; continue; } ifr6.ifr6_ifindex = ifr.ifr_ifindex; ifr6.ifr6_prefixlen = prefix_len; if (ioctl(fd, SIOCSIFDSTADDR, &ifr6) < 0) { fprintf(stderr, "SIOCSIFDSTADDR: %s\n", strerror(errno)); goterr = 1; } spp++; continue; } #endif /* If the next argument is a valid hostname, assume OK. */ safe_strncpy(host, *spp, (sizeof host)); /* FIXME: sa is too small for INET6 addresses, inet6 should use that too, broadcast is unexpected */ if (ap->getmask) { switch (ap->getmask(host, &sa, NULL)) { case -1: usage(); break; case 1: if (didnetmask) usage(); goterr = set_netmask(skfd, &ifr, &sa); didnetmask++; break; } } if (ap->input(0, host, &sa) < 0) { ap->herror(host); usage(); } memcpy((char *) &ifr.ifr_addr, (char *) &sa, sizeof(struct sockaddr)); { int r = 0; /* to shut gcc up */ switch (ap->af) { #if HAVE_AFINET case AF_INET: fd = get_socket_for_af(AF_INET); if (fd < 0) { fprintf(stderr, _("No support for INET on this system.\n")); exit(1); } r = ioctl(fd, SIOCSIFADDR, &ifr); break; #endif #if HAVE_AFECONET case AF_ECONET: fd = get_socket_for_af(AF_ECONET); if (fd < 0) { fprintf(stderr, _("No support for ECONET on this system.\n")); exit(1); } r = ioctl(fd, SIOCSIFADDR, &ifr); break; #endif default: fprintf(stderr, _("Don't know how to set addresses for family %d.\n"), ap->af); exit(1); } if (r < 0) { perror("SIOCSIFADDR"); goterr = 1; } } /* * Don't do the set_flag() if the address is an alias with a - at the * end, since it's deleted already! - Roman * * Should really use regex.h here, not sure though how well it'll go * with the cross-platform support etc. */ { char *ptr; short int found_colon = 0; for (ptr = ifr.ifr_name; *ptr; ptr++ ) if (*ptr == ':') found_colon++; if (!(found_colon && *(ptr - 1) == '-')) goterr |= set_flag(ifr.ifr_name, (IFF_UP | IFF_RUNNING)); } spp++; } return (goterr); }
void ticTacToeGame( int * optionStats ) { char matrix[NUM_ROWS][NUM_COLS]= {{'1','2','3'},{'4','5','6'},{'7','8','9'}}; char buffer[1 + EXTRA_SPACES]; int playerNum = 1; int turnCount=0; int selection=0; /*drawGrid(*boardTurns)*/ for (turnCount=0; turnCount <= MAX_TURNS; turnCount++) { if ( playerNum == 1 ) { int x =0; int y =0; char check=NULL; char* prompt = "Player #1 select a square: "; char *p; /*implement for player two aswell */ drawBoard(matrix); getString(buffer, 1 + EXTRA_SPACES, prompt); selection= strtol(buffer, &p, 10); /*validateNumericInput(selection, buffer, 1 + EXTRA_SPACES, prompt);*/ /*check if input is non-numeric*/ if ((selection < 0) || (selection > 9)) { printf("invalid selection. please try again"); } if (buffer[0] == '\0') { printf("Exiting to Main Menu.... \n \n"); return; } if ((buffer[0] != '\n') && (*p == '\n' || *p == '\0')) { if (selection <= 9 && selection > 0 ) { for (x=0; x < NUM_ROWS; x++) { for (y=0; y < NUM_COLS; y++) { /*better way of finding char value of user input - although vlidation already performed so input should be ok to straight convert*/ if ( matrix[x][y] == (char)buffer[0] ) { matrix[x][y]='X'; } } } } else /*need to loop and reprompt for inpt */ printf("Invalid option."); } /*assign selection to board[][]*/ check=checkWin(matrix); if (check != NULL) { printf("\n Player %c WON!\n", check); drawBoard(matrix); printf("Returning to menu"); (optionStats[3])++; return; } playerNum=2; } if ( playerNum == 2 ) { int x=0; int y=0; char check=NULL; char *prompt = "Player #2 select a square: "; char *p; drawBoard(matrix); getString(buffer, 1 + EXTRA_SPACES, prompt); selection=strtol(buffer, &p, 10); if ((selection < 0) || (selection >9)) { printf("invalid selection. please try again \n"); } if (buffer[0] == '\0') { printf("Exiting to Main Menu.... \n \n"); return; } else if ((buffer[0] != '\n') && ( *p == '\n' || *p == '\0')) { /*check for non numeric characters - also semi done in selection check */ if (selection <= 9 && selection > 0) { for (x=0; x < NUM_ROWS; x++) { for (y=0; y < NUM_COLS; y++) { if ( matrix[x][y] == (char)buffer[0]) { matrix[x][y]='O'; } } } } else printf("invalid Range"); } check=checkWin(matrix); if (check != NULL) { printf("\nPlayer %c WON!\n", check); drawBoard(matrix); printf("Returning to Menu\n"); (optionStats[3])++; return; } playerNum=1; } } }
/**************************************************************************** * This function prompts the user for a integer N and several lines of * text (sentences between 150-200 characters. The text will be printed * N characters per line, by adding extra spaces as evenly as possible * so there are no broken words. See requirement #6 in the assignment * specification. ****************************************************************************/ void formattingText(int *optionStats) { char *prompt1= "Enter a max number of characters per line: "; char *prompt2= "Enter a sentence (between 150-200) characters: "; char buffer [200 + EXTRA_SPACES]; char linefeeder [200 + EXTRA_SPACES]; char number [3+ EXTRA_SPACES]; int MAX_CHARS_LINE; char *p; int i; char SPACE = ' '; int pointer; int spacecounter; int insertcounter; getString(number, 3 + EXTRA_SPACES, prompt1); MAX_CHARS_LINE = strtol(number,&p,10); if(number[0] == '\0') { printf("Exiting to Main Menu.... \n"); return; } getString(buffer, 200 + EXTRA_SPACES, prompt2); if(buffer[0] == '\0') { printf("Exiting to Main Menu.... \n"); return; } printf("%d - max number \n", MAX_CHARS_LINE); printf("%s \n", buffer); /*initialise the pointer for the string*/ pointer = (MAX_CHARS_LINE-1); /*all in a while loop */ while (buffer[pointer] != '\0') { /*is char is a space*/ /*clear out linefeeder before using again*/ if (buffer[pointer] == SPACE) { printf("space detected"); spacecounter=0; /*copy upto MAX_CHARS into linefeeder and print out*/ for(i=0;i <= (MAX_CHARS_LINE-1); i++) { if (buffer[i] == SPACE) { spacecounter++; } linefeeder[i] = buffer[i]; } linefeeder[MAX_CHARS_LINE] = '\n'; pointer=pointer+ MAX_CHARS_LINE; printf("%s ...spaces: %d\n",linefeeder, spacecounter); } /*if char is not a space*/ if (buffer[pointer] != SPACE) { printf("Character detected"); /*initiliase the counters of characters iterated and spaces already in array*/ spacecounter=0; insertcounter=0; while (buffer[pointer] != SPACE) { pointer--; insertcounter++; } for (i=pointer; i <=( (MAX_CHARS_LINE-1) + pointer); i++) { if (buffer[i] == SPACE) { spacecounter++; } } printf(" %d spaces should be inserted. Currently %d spaces.", insertcounter, spacecounter); if (buffer[pointer] == SPACE) { /*write to line feeder adding in extra spaces evenly*/ } } } }
int main(int argc, char **argv) { int ch, longindex, ret; unsigned long flags; struct option *long_options; const struct command *commands; const char *short_options; char *p; const struct sd_option *sd_opts; init_commands(&commands); if (argc < 3) usage(commands, 0); flags = setup_commands(commands, argv[1], argv[2]); optind = 3; sd_opts = build_sd_options(command_opts); long_options = build_long_options(sd_opts); short_options = build_short_options(sd_opts); while ((ch = getopt_long(argc, argv, short_options, long_options, &longindex)) >= 0) { switch (ch) { case 'a': sdhost = optarg; break; case 'p': sdport = strtol(optarg, &p, 10); if (optarg == p || sdport < 1 || sdport > UINT16_MAX) { fprintf(stderr, "Invalid port number '%s'\n", optarg); exit(EXIT_USAGE); } break; case 'r': raw_output = true; break; case 'h': subcommand_usage(argv[1], argv[2], EXIT_SUCCESS); break; case '?': usage(commands, EXIT_USAGE); break; default: if (command_parser) command_parser(ch, optarg); else usage(commands, EXIT_USAGE); break; } } if (!isatty(STDOUT_FILENO) || raw_output) highlight = false; if (flags & SUBCMD_FLAG_NEED_NODELIST) { ret = update_node_list(SD_MAX_NODES, 0); if (ret < 0) { fprintf(stderr, "Failed to get node list\n"); exit(EXIT_SYSFAIL); } } if (flags & SUBCMD_FLAG_NEED_THIRD_ARG && argc == optind) subcommand_usage(argv[1], argv[2], EXIT_USAGE); return command_fn(argc, argv); }
int main(int argc, char *argv[]) { gen_workspace *gen_workspace_p; lapack_workspace *lapack_workspace_p; size_t N; int c; int lower; int upper; int incremental; size_t nmat; gsl_matrix *A, *B; gsl_rng *r; int s; int compute_schur; size_t i; gsl_ieee_env_setup(); gsl_rng_env_setup(); N = 30; lower = -10; upper = 10; incremental = 0; nmat = 0; compute_schur = 0; while ((c = getopt(argc, argv, "ic:n:l:u:z")) != (-1)) { switch (c) { case 'i': incremental = 1; break; case 'n': N = strtol(optarg, NULL, 0); break; case 'l': lower = strtol(optarg, NULL, 0); break; case 'u': upper = strtol(optarg, NULL, 0); break; case 'c': nmat = strtoul(optarg, NULL, 0); break; case 'z': compute_schur = 1; break; case '?': default: printf("usage: %s [-i] [-z] [-n size] [-l lower-bound] [-u upper-bound] [-c num]\n", argv[0]); exit(1); break; } /* switch (c) */ } A = gsl_matrix_alloc(N, N); B = gsl_matrix_alloc(N, N); gen_workspace_p = gen_alloc(N, compute_schur); lapack_workspace_p = lapack_alloc(N); r = gsl_rng_alloc(gsl_rng_default); if (incremental) { make_start_matrix(A, lower); /* we need B to be non-singular */ make_random_integer_matrix(B, r, lower, upper); } fprintf(stderr, "testing N = %d", N); if (incremental) fprintf(stderr, " incrementally"); else fprintf(stderr, " randomly"); fprintf(stderr, " on element range [%d, %d]", lower, upper); if (compute_schur) fprintf(stderr, ", with Schur vectors"); fprintf(stderr, "\n"); while (1) { if (nmat && (count >= nmat)) break; ++count; if (!incremental) { make_random_matrix(A, r, lower, upper); make_random_matrix(B, r, lower, upper); } else { s = inc_matrix(A, lower, upper); if (s) break; /* all done */ make_random_integer_matrix(B, r, lower, upper); } /*if (count != 89120) continue;*/ /* make copies of matrices */ gsl_matrix_memcpy(gen_workspace_p->A, A); gsl_matrix_memcpy(gen_workspace_p->B, B); gsl_matrix_transpose_memcpy(lapack_workspace_p->A, A); gsl_matrix_transpose_memcpy(lapack_workspace_p->B, B); /* compute eigenvalues with LAPACK */ s = lapack_proc(lapack_workspace_p); if (s != GSL_SUCCESS) { printf("LAPACK failed, case %lu\n", count); exit(1); } #if 0 print_matrix(A, "A"); print_matrix(B, "B"); gsl_matrix_transpose(lapack_workspace_p->A); gsl_matrix_transpose(lapack_workspace_p->B); print_matrix(lapack_workspace_p->A, "S_lapack"); print_matrix(lapack_workspace_p->B, "T_lapack"); #endif /* compute eigenvalues with GSL */ s = gen_proc(gen_workspace_p); if (s != GSL_SUCCESS) { printf("=========== CASE %lu ============\n", count); printf("Failed to converge: found %u eigenvalues\n", gen_workspace_p->n_evals); print_matrix(A, "A"); print_matrix(B, "B"); print_matrix(gen_workspace_p->A, "Af"); print_matrix(gen_workspace_p->B, "Bf"); print_matrix(lapack_workspace_p->A, "Ae"); print_matrix(lapack_workspace_p->B, "Be"); exit(1); } #if 0 print_matrix(gen_workspace_p->A, "S_gsl"); print_matrix(gen_workspace_p->B, "T_gsl"); #endif /* compute alpha / beta vectors */ for (i = 0; i < N; ++i) { double beta; gsl_complex alpha, z; beta = gsl_vector_get(gen_workspace_p->beta, i); if (beta == 0.0) GSL_SET_COMPLEX(&z, GSL_POSINF, GSL_POSINF); else { alpha = gsl_vector_complex_get(gen_workspace_p->alpha, i); z = gsl_complex_div_real(alpha, beta); } gsl_vector_complex_set(gen_workspace_p->evals, i, z); beta = gsl_vector_get(lapack_workspace_p->beta, i); GSL_SET_COMPLEX(&alpha, lapack_workspace_p->alphar[i], lapack_workspace_p->alphai[i]); if (beta == 0.0) GSL_SET_COMPLEX(&z, GSL_POSINF, GSL_POSINF); else z = gsl_complex_div_real(alpha, beta); gsl_vector_complex_set(lapack_workspace_p->evals, i, z); gsl_vector_complex_set(lapack_workspace_p->alpha, i, alpha); } #if 0 gsl_sort_vector(gen_workspace_p->beta); gsl_sort_vector(lapack_workspace_p->beta); sort_complex_vector(gen_workspace_p->alpha); sort_complex_vector(lapack_workspace_p->alpha); s = test_alpha(gen_workspace_p->alpha, lapack_workspace_p->alpha, A, B, "gen", "lapack"); s = test_beta(gen_workspace_p->beta, lapack_workspace_p->beta, A, B, "gen", "lapack"); #endif #if 1 sort_complex_vector(gen_workspace_p->evals); sort_complex_vector(lapack_workspace_p->evals); s = test_evals(gen_workspace_p->evals, lapack_workspace_p->evals, A, B, "gen", "lapack"); #endif if (compute_schur) { test_schur(A, gen_workspace_p->A, gen_workspace_p->Q, gen_workspace_p->Z); test_schur(B, gen_workspace_p->B, gen_workspace_p->Q, gen_workspace_p->Z); } } gsl_matrix_free(A); gsl_matrix_free(B); gen_free(gen_workspace_p); lapack_free(lapack_workspace_p); if (r) gsl_rng_free(r); return 0; } /* main() */
static jboolean parseOptions(char *options) { TransportSpec *currentTransport = NULL; char *end; char *current; int length; char *str; char *errmsg; /* Set defaults */ gdata->assertOn = DEFAULT_ASSERT_ON; gdata->assertFatal = DEFAULT_ASSERT_FATAL; logfile = DEFAULT_LOGFILE; /* Options being NULL will end up being an error. */ if (options == NULL) { options = ""; } /* Check for "help" BEFORE we add any environmental settings */ if ((strcmp(options, "help")) == 0) { printUsage(); forceExit(0); /* Kill entire process, no core dump wanted */ } /* These buffers are never freed */ { char *envOptions; /* * Add environmentally specified options. */ envOptions = getenv("_JAVA_JDWP_OPTIONS"); if (envOptions != NULL) { options = add_to_options(options, envOptions); if ( options==NULL ) { EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"options"); } } /* * Allocate a buffer for names derived from option strings. It should * never be longer than the original options string itself. * Also keep a copy of the options in gdata->options. */ length = (int)strlen(options); gdata->options = jvmtiAllocate(length + 1); if (gdata->options == NULL) { EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"options"); } (void)strcpy(gdata->options, options); names = jvmtiAllocate(length + 1); if (names == NULL) { EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"options"); } transports = bagCreateBag(sizeof(TransportSpec), 3); if (transports == NULL) { EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"transports"); } } current = names; end = names + length; str = options; while (*str) { char buf[100]; /*LINTED*/ if (!get_tok(&str, buf, (int)sizeof(buf), '=')) { goto syntax_error; } if (strcmp(buf, "transport") == 0) { currentTransport = bagAdd(transports); /*LINTED*/ if (!get_tok(&str, current, (int)(end - current), ',')) { goto syntax_error; } currentTransport->name = current; current += strlen(current) + 1; } else if (strcmp(buf, "address") == 0) { if (currentTransport == NULL) { errmsg = "address specified without transport"; goto bad_option_with_errmsg; } /*LINTED*/ if (!get_tok(&str, current, (int)(end - current), ',')) { goto syntax_error; } currentTransport->address = current; current += strlen(current) + 1; } else if (strcmp(buf, "timeout") == 0) { if (currentTransport == NULL) { errmsg = "timeout specified without transport"; goto bad_option_with_errmsg; } /*LINTED*/ if (!get_tok(&str, current, (int)(end - current), ',')) { goto syntax_error; } currentTransport->timeout = atol(current); current += strlen(current) + 1; } else if (strcmp(buf, "launch") == 0) { /*LINTED*/ if (!get_tok(&str, current, (int)(end - current), ',')) { goto syntax_error; } launchOnInit = current; current += strlen(current) + 1; } else if (strcmp(buf, "onthrow") == 0) { /* Read class name and convert in place to a signature */ *current = 'L'; /*LINTED*/ if (!get_tok(&str, current + 1, (int)(end - current - 1), ',')) { goto syntax_error; } initOnException = current; while (*current != '\0') { if (*current == '.') { *current = '/'; } current++; } *current++ = ';'; *current++ = '\0'; } else if (strcmp(buf, "assert") == 0) { /*LINTED*/ if (!get_tok(&str, current, (int)(end - current), ',')) { goto syntax_error; } if (strcmp(current, "y") == 0) { gdata->assertOn = JNI_TRUE; gdata->assertFatal = JNI_FALSE; } else if (strcmp(current, "fatal") == 0) { gdata->assertOn = JNI_TRUE; gdata->assertFatal = JNI_TRUE; } else if (strcmp(current, "n") == 0) { gdata->assertOn = JNI_FALSE; gdata->assertFatal = JNI_FALSE; } else { goto syntax_error; } current += strlen(current) + 1; } else if (strcmp(buf, "pause") == 0) { if ( !get_boolean(&str, &dopause) ) { goto syntax_error; } if ( dopause ) { do_pause(); } } else if (strcmp(buf, "coredump") == 0) { if ( !get_boolean(&str, &docoredump) ) { goto syntax_error; } } else if (strcmp(buf, "errorexit") == 0) { if ( !get_boolean(&str, &(gdata->doerrorexit)) ) { goto syntax_error; } } else if (strcmp(buf, "exitpause") == 0) { errmsg = "The exitpause option removed, use -XX:OnError"; goto bad_option_with_errmsg; } else if (strcmp(buf, "precrash") == 0) { errmsg = "The precrash option removed, use -XX:OnError"; goto bad_option_with_errmsg; } else if (strcmp(buf, "logfile") == 0) { /*LINTED*/ if (!get_tok(&str, current, (int)(end - current), ',')) { goto syntax_error; } logfile = current; current += strlen(current) + 1; } else if (strcmp(buf, "logflags") == 0) { /*LINTED*/ if (!get_tok(&str, current, (int)(end - current), ',')) { goto syntax_error; } /*LINTED*/ logflags = (unsigned)strtol(current, NULL, 0); } else if (strcmp(buf, "debugflags") == 0) { /*LINTED*/ if (!get_tok(&str, current, (int)(end - current), ',')) { goto syntax_error; } /*LINTED*/ gdata->debugflags = (unsigned)strtol(current, NULL, 0); } else if ( strcmp(buf, "suspend")==0 ) { if ( !get_boolean(&str, &suspendOnInit) ) { goto syntax_error; } } else if ( strcmp(buf, "server")==0 ) { if ( !get_boolean(&str, &isServer) ) { goto syntax_error; } } else if ( strcmp(buf, "strict")==0 ) { /* Obsolete, but accept it */ if ( !get_boolean(&str, &isStrict) ) { goto syntax_error; } } else if ( strcmp(buf, "quiet")==0 ) { if ( !get_boolean(&str, &(gdata->quiet)) ) { goto syntax_error; } } else if ( strcmp(buf, "onuncaught")==0 ) { if ( !get_boolean(&str, &initOnUncaught) ) { goto syntax_error; } } else if ( strcmp(buf, "mutf8")==0 ) { if ( !get_boolean(&str, &(gdata->modifiedUtf8)) ) { goto syntax_error; } } else if ( strcmp(buf, "stdalloc")==0 ) { /* Obsolete, but accept it */ if ( !get_boolean(&str, &useStandardAlloc) ) { goto syntax_error; } } else { goto syntax_error; } } /* Setup logging now */ if ( logfile!=NULL ) { setup_logging(logfile, logflags); (void)atexit(&atexit_finish_logging); } if (bagSize(transports) == 0) { errmsg = "no transport specified"; goto bad_option_with_errmsg; } /* * TO DO: Remove when multiple transports are allowed. (replace with * check below. */ if (bagSize(transports) > 1) { errmsg = "multiple transports are not supported in this release"; goto bad_option_with_errmsg; } if (!isServer) { jboolean specified = bagEnumerateOver(transports, checkAddress, NULL); if (!specified) { /* message already printed */ goto bad_option_no_msg; } } /* * The user has selected to wait for an exception before init happens */ if ((initOnException != NULL) || (initOnUncaught)) { initOnStartup = JNI_FALSE; if (launchOnInit == NULL) { /* * These rely on the launch=/usr/bin/foo * suboption, so it is an error if user did not * provide one. */ errmsg = "Specify launch=<command line> when using onthrow or onuncaught suboption"; goto bad_option_with_errmsg; } } return JNI_TRUE; syntax_error: ERROR_MESSAGE(("JDWP option syntax error: %s=%s", AGENTLIB, options)); return JNI_FALSE; bad_option_with_errmsg: ERROR_MESSAGE(("JDWP %s: %s=%s", errmsg, AGENTLIB, options)); return JNI_FALSE; bad_option_no_msg: ERROR_MESSAGE(("JDWP %s: %s=%s", "invalid option", AGENTLIB, options)); return JNI_FALSE; }
/* * get either 1 or 2 integers for a resource count in the form of either * (count, min-max, or '*') * A partial error message is passed in via the 'what' param. * IN arg - argument * IN what - variable name (for errors) * OUT min - first number * OUT max - maximum value if specified, NULL if don't care * IN isFatal - if set, exit on error * RET true if valid */ bool get_resource_arg_range(const char *arg, const char *what, int* min, int *max, bool isFatal) { char *p; long int result; /* wildcard meaning every possible value in range */ if ((*arg == '\0') || (*arg == '*' )) { *min = 1; if (max) *max = INT_MAX; return true; } result = strtol(arg, &p, 10); if (*p == 'k' || *p == 'K') { result *= 1024; p++; } else if (*p == 'm' || *p == 'M') { result *= 1048576; p++; } if (((*p != '\0') && (*p != '-')) || (result <= 0L)) { error ("Invalid numeric value \"%s\" for %s.", arg, what); if (isFatal) exit(1); return false; } else if (result > INT_MAX) { error ("Numeric argument (%ld) to big for %s.", result, what); if (isFatal) exit(1); return false; } *min = (int) result; if (*p == '\0') return true; if (*p == '-') p++; result = strtol(p, &p, 10); if ((*p == 'k') || (*p == 'K')) { result *= 1024; p++; } else if (*p == 'm' || *p == 'M') { result *= 1048576; p++; } if (((*p != '\0') && (*p != '-')) || (result <= 0L)) { error ("Invalid numeric value \"%s\" for %s.", arg, what); if (isFatal) exit(1); return false; } else if (result > INT_MAX) { error ("Numeric argument (%ld) to big for %s.", result, what); if (isFatal) exit(1); return false; } if (max) *max = (int) result; return true; }
void fs2netd_options_config_init() { if (PXO_options_loaded) { return; } if ( !strlen(Multi_options_g.game_tracker_ip) ) { ml_printf("NOTICE: Address for game tracker not specified, using default instead (%s).", FS2NETD_DEFAULT_SERVER); strncpy( Multi_options_g.game_tracker_ip, FS2NETD_DEFAULT_SERVER, MULTI_OPTIONS_STRING_LEN ); } else if ( !strcmp("gt.pxo.net", Multi_options_g.game_tracker_ip) ) { ml_printf("NOTICE: Incompatible game tracker IP detected (gt.pxo.net), using default instead (%s)!", FS2NETD_DEFAULT_SERVER); strncpy( Multi_options_g.game_tracker_ip, FS2NETD_DEFAULT_SERVER, MULTI_OPTIONS_STRING_LEN ); } if ( !strlen(Multi_options_g.user_tracker_ip) ) { ml_printf("NOTICE: Address for user tracker not specified, using default instead (%s).", FS2NETD_DEFAULT_SERVER); strncpy( Multi_options_g.user_tracker_ip, FS2NETD_DEFAULT_SERVER, MULTI_OPTIONS_STRING_LEN ); } else if ( !strcmp("ut.pxo.net", Multi_options_g.user_tracker_ip) ) { ml_printf("NOTICE: Incompatible user tracker IP detected (ut.pxo.net), using default instead (%s)!", FS2NETD_DEFAULT_SERVER); strncpy( Multi_options_g.user_tracker_ip, FS2NETD_DEFAULT_SERVER, MULTI_OPTIONS_STRING_LEN ); } if ( !strlen(Multi_options_g.tracker_port) ) { if ( FS2NetD_port >= 1024 && FS2NetD_port <= USHRT_MAX ) { ml_printf("NOTICE: User override for game/user tracker port not specified, using game_settings.tbl override (%i).", FS2NetD_port); int result; result = sprintf(Multi_options_g.tracker_port, "%i", FS2NetD_port); Assertion( result > 0, "Copying port %i to tracker_port failed\n", FS2NetD_port ); } else { if ( FS2NetD_port != 0 ) { ml_printf("ERROR: game_settings.tbl override for game/user tracker port '%i' must be between %i and %i.", FS2NetD_port, 1024, USHRT_MAX); } ml_printf("NOTICE: Port for game/user trackers not specified, using default instead (%s).", FS2NETD_DEFAULT_PORT); strncpy( Multi_options_g.tracker_port, FS2NETD_DEFAULT_PORT, STD_NAME_LEN ); } } else { long port_tmp = strtol(Multi_options_g.tracker_port, (char**)NULL, 10); if ( (port_tmp < 1024) || (port_tmp > USHRT_MAX) ) { ml_printf("NOTICE: The port specified for game/user trackers, '%ld', is outside of the required range, %i through %i!", port_tmp, 1024, USHRT_MAX); ml_printf("NOTICE: Port for game/user trackers is invalid, using default instead (%s).", FS2NETD_DEFAULT_PORT); strncpy( Multi_options_g.tracker_port, FS2NETD_DEFAULT_PORT, STD_NAME_LEN ); } } if ( !strlen(Multi_options_g.pxo_ip) ) { ml_printf("NOTICE: Address for chat server not specified, using default instead (%s).", FS2NETD_DEFAULT_CHAT_SERVER); strncpy( Multi_options_g.pxo_ip, FS2NETD_DEFAULT_CHAT_SERVER, MULTI_OPTIONS_STRING_LEN ); } else if ( !strcmp("chat.pxo.net", Multi_options_g.pxo_ip) ) { ml_printf("NOTICE: Incompatible chat server IP detected (chat.pxo.net), using default instead (%s)!", FS2NETD_DEFAULT_CHAT_SERVER); strncpy( Multi_options_g.pxo_ip, FS2NETD_DEFAULT_CHAT_SERVER, MULTI_OPTIONS_STRING_LEN ); } if ( !strlen(Multi_options_g.pxo_banner_url) ) { ml_printf("NOTICE: URL for banners not specified, using default instead (%s).", FS2NETD_DEFAULT_BANNER_URL); strncpy( Multi_options_g.pxo_banner_url, FS2NETD_DEFAULT_BANNER_URL, MULTI_OPTIONS_STRING_LEN ); } else if ( !strcmp("http://www.pxo.net/files/banners", Multi_options_g.pxo_banner_url) ) { ml_printf("NOTICE: Incompatible banner URL detected (chat.pxo.net), using default instead (%s)!", FS2NETD_DEFAULT_BANNER_URL); strncpy( Multi_options_g.pxo_banner_url, FS2NETD_DEFAULT_BANNER_URL, MULTI_OPTIONS_STRING_LEN ); } PXO_options_loaded = true; }
void erl_start(int argc, char **argv) { int i = 1; char* arg=NULL; int have_break_handler = 1; char envbuf[21]; /* enough for any 64-bit integer */ size_t envbufsz; int ncpu = early_init(&argc, argv); int proc_tab_sz = ERTS_DEFAULT_MAX_PROCESSES; int port_tab_sz = ERTS_DEFAULT_MAX_PORTS; int port_tab_sz_ignore_files = 0; int legacy_proc_tab = 0; int legacy_port_tab = 0; envbufsz = sizeof(envbuf); if (erts_sys_getenv_raw(ERL_MAX_ETS_TABLES_ENV, envbuf, &envbufsz) == 0) user_requested_db_max_tabs = atoi(envbuf); else user_requested_db_max_tabs = 0; envbufsz = sizeof(envbuf); if (erts_sys_getenv_raw("ERL_FULLSWEEP_AFTER", envbuf, &envbufsz) == 0) { Uint16 max_gen_gcs = atoi(envbuf); erts_smp_atomic32_set_nob(&erts_max_gen_gcs, (erts_aint32_t) max_gen_gcs); } envbufsz = sizeof(envbuf); if (erts_sys_getenv_raw("ERL_MAX_PORTS", envbuf, &envbufsz) == 0) { port_tab_sz = atoi(envbuf); port_tab_sz_ignore_files = 1; } #if (defined(__APPLE__) && defined(__MACH__)) || defined(__DARWIN__) /* * The default stack size on MacOS X is too small for pcre. */ erts_sched_thread_suggested_stack_size = 256; #endif #ifdef DEBUG verbose = DEBUG_DEFAULT; #endif erts_error_logger_warnings = am_error; while (i < argc) { if (argv[i][0] != '-') { erts_usage(); } if (strcmp(argv[i], "--") == 0) { /* end of emulator options */ i++; break; } switch (argv[i][1]) { /* * NOTE: -M flags are handled (and removed from argv) by * erts_alloc_init(). * * The -d, -m, -S, -t, and -T flags was removed in * Erlang 5.3/OTP R9C. * * -S, and -T has been reused in Erlang 5.5/OTP R11B. * * -d has been reused in a patch R12B-4. */ case '#' : arg = get_arg(argv[i]+2, argv[i+1], &i); if ((display_items = atoi(arg)) == 0) { erts_fprintf(stderr, "bad display items%s\n", arg); erts_usage(); } VERBOSE(DEBUG_SYSTEM, ("using display items %d\n",display_items)); break; case 'p': if (!strncmp(argv[i],"-pc",3)) { int printable_chars = ERL_PRINTABLE_CHARACTERS_LATIN1; arg = get_arg(argv[i]+3, argv[i+1], &i); if (!strcmp(arg,"unicode")) { printable_chars = ERL_PRINTABLE_CHARACTERS_UNICODE; } else if (strcmp(arg,"latin1")) { erts_fprintf(stderr, "bad range of printable " "characters: %s\n", arg); erts_usage(); } erts_set_printable_characters(printable_chars); break; } else { erts_fprintf(stderr, "%s unknown flag %s\n", argv[0], argv[i]); erts_usage(); } case 'f': if (!strncmp(argv[i],"-fn",3)) { int warning_type = ERL_FILENAME_WARNING_WARNING; arg = get_arg(argv[i]+3, argv[i+1], &i); switch (*arg) { case 'u': switch (*(arg+1)) { case 'w': case 0: break; case 'i': warning_type = ERL_FILENAME_WARNING_IGNORE; break; case 'e': warning_type = ERL_FILENAME_WARNING_ERROR; break; default: erts_fprintf(stderr, "bad type of warnings for " "wrongly coded filename: %s\n", arg+1); erts_usage(); } erts_set_user_requested_filename_encoding ( ERL_FILENAME_UTF8, warning_type ); break; case 'l': erts_set_user_requested_filename_encoding ( ERL_FILENAME_LATIN1, warning_type ); break; case 'a': switch (*(arg+1)) { case 'w': case 0: break; case 'i': warning_type = ERL_FILENAME_WARNING_IGNORE; break; case 'e': warning_type = ERL_FILENAME_WARNING_ERROR; break; default: erts_fprintf(stderr, "bad type of warnings for " "wrongly coded filename: %s\n", arg+1); erts_usage(); } erts_set_user_requested_filename_encoding ( ERL_FILENAME_UNKNOWN, warning_type ); break; default: erts_fprintf(stderr, "bad filename encoding %s, can be " "(l,u or a, optionally followed by w, " "i or e)\n", arg); erts_usage(); } break; } else { erts_fprintf(stderr, "%s unknown flag %s\n", argv[0], argv[i]); erts_usage(); } case 'L': erts_no_line_info = 1; break; case 'v': #ifdef DEBUG if (argv[i][2] == '\0') { verbose |= DEBUG_SYSTEM; } else { char *ch; for (ch = argv[i]+2; *ch != '\0'; ch++) { switch (*ch) { case 's': verbose |= DEBUG_SYSTEM; break; case 'g': verbose |= DEBUG_PRIVATE_GC; break; case 'M': verbose |= DEBUG_MEMORY; break; case 'a': verbose |= DEBUG_ALLOCATION; break; case 't': verbose |= DEBUG_THREADS; break; case 'p': verbose |= DEBUG_PROCESSES; break; case 'm': verbose |= DEBUG_MESSAGES; break; default : erts_fprintf(stderr,"Unknown verbose option: %c\n",*ch); } } } erts_printf("Verbose level: "); if (verbose & DEBUG_SYSTEM) erts_printf("SYSTEM "); if (verbose & DEBUG_PRIVATE_GC) erts_printf("PRIVATE_GC "); if (verbose & DEBUG_MEMORY) erts_printf("PARANOID_MEMORY "); if (verbose & DEBUG_ALLOCATION) erts_printf("ALLOCATION "); if (verbose & DEBUG_THREADS) erts_printf("THREADS "); if (verbose & DEBUG_PROCESSES) erts_printf("PROCESSES "); if (verbose & DEBUG_MESSAGES) erts_printf("MESSAGES "); erts_printf("\n"); #else erts_fprintf(stderr, "warning: -v (only in debug compiled code)\n"); #endif break; case 'V' : { char tmp[256]; tmp[0] = tmp[1] = '\0'; #ifdef DEBUG strcat(tmp, ",DEBUG"); #endif #ifdef ERTS_SMP strcat(tmp, ",SMP"); #endif #ifdef USE_THREADS strcat(tmp, ",ASYNC_THREADS"); #endif #ifdef HIPE strcat(tmp, ",HIPE"); #endif erts_fprintf(stderr, "Erlang "); if (tmp[1]) { erts_fprintf(stderr, "(%s) ", tmp+1); } erts_fprintf(stderr, "(" EMULATOR ") emulator version " ERLANG_VERSION "\n"); erl_exit(0, ""); } break; case 'H': /* undocumented */ fprintf(stderr, "The undocumented +H option has been removed (R10B-6).\n\n"); break; case 'h': { char *sub_param = argv[i]+2; /* set default heap size * * h|ms - min_heap_size * h|mbs - min_bin_vheap_size * */ if (has_prefix("mbs", sub_param)) { arg = get_arg(sub_param+3, argv[i+1], &i); if ((BIN_VH_MIN_SIZE = atoi(arg)) <= 0) { erts_fprintf(stderr, "bad heap size %s\n", arg); erts_usage(); } VERBOSE(DEBUG_SYSTEM, ("using minimum binary virtual heap size %d\n", BIN_VH_MIN_SIZE)); } else if (has_prefix("ms", sub_param)) { arg = get_arg(sub_param+2, argv[i+1], &i); if ((H_MIN_SIZE = atoi(arg)) <= 0) { erts_fprintf(stderr, "bad heap size %s\n", arg); erts_usage(); } VERBOSE(DEBUG_SYSTEM, ("using minimum heap size %d\n", H_MIN_SIZE)); } else { /* backward compatibility */ arg = get_arg(argv[i]+2, argv[i+1], &i); if ((H_MIN_SIZE = atoi(arg)) <= 0) { erts_fprintf(stderr, "bad heap size %s\n", arg); erts_usage(); } VERBOSE(DEBUG_SYSTEM, ("using minimum heap size %d\n", H_MIN_SIZE)); } break; } case 'd': /* * Never produce crash dumps for internally detected * errors; only produce a core dump. (Generation of * crash dumps is destructive and makes it impossible * to inspect the contents of process heaps in the * core dump.) */ erts_no_crash_dump = 1; break; case 'e': if (sys_strcmp("c", argv[i]+2) == 0) { erts_ets_always_compress = 1; } else { /* set maximum number of ets tables */ arg = get_arg(argv[i]+2, argv[i+1], &i); if (( user_requested_db_max_tabs = atoi(arg) ) < 0) { erts_fprintf(stderr, "bad maximum number of ets tables %s\n", arg); erts_usage(); } VERBOSE(DEBUG_SYSTEM, ("using maximum number of ets tables %d\n", user_requested_db_max_tabs)); } break; case 'i': /* define name of module for initial function */ init = get_arg(argv[i]+2, argv[i+1], &i); break; case 'b': /* define name of initial function */ boot = get_arg(argv[i]+2, argv[i+1], &i); break; case 'B': if (argv[i][2] == 'i') /* +Bi */ ignore_break = 1; else if (argv[i][2] == 'c') /* +Bc */ replace_intr = 1; else if (argv[i][2] == 'd') /* +Bd */ have_break_handler = 0; else if (argv[i+1][0] == 'i') { /* +B i */ get_arg(argv[i]+2, argv[i+1], &i); ignore_break = 1; } else if (argv[i+1][0] == 'c') { /* +B c */ get_arg(argv[i]+2, argv[i+1], &i); replace_intr = 1; } else if (argv[i+1][0] == 'd') { /* +B d */ get_arg(argv[i]+2, argv[i+1], &i); have_break_handler = 0; } else /* +B */ have_break_handler = 0; break; case 'K': /* If kernel poll support is present, erl_sys_args() will remove the K parameter and value */ get_arg(argv[i]+2, argv[i+1], &i); erts_fprintf(stderr, "kernel-poll not supported; \"K\" parameter ignored\n", arg); break; case 'n': arg = get_arg(argv[i]+2, argv[i+1], &i); switch (arg[0]) { case 's': /* synchronous */ erts_port_synchronous_ops = 1; erts_port_schedule_all_ops = 0; break; case 'a': /* asynchronous */ erts_port_synchronous_ops = 0; erts_port_schedule_all_ops = 1; break; case 'd': /* Default - schedule on conflict (asynchronous) */ erts_port_synchronous_ops = 0; erts_port_schedule_all_ops = 0; break; default: bad_n_option: erts_fprintf(stderr, "bad -n option %s\n", arg); erts_usage(); } if (arg[1] != '\0') goto bad_n_option; break; case 'P': /* set maximum number of processes */ arg = get_arg(argv[i]+2, argv[i+1], &i); if (strcmp(arg, "legacy") == 0) legacy_proc_tab = 1; else { errno = 0; proc_tab_sz = strtol(arg, NULL, 10); if (errno != 0 || proc_tab_sz < ERTS_MIN_PROCESSES || ERTS_MAX_PROCESSES < proc_tab_sz) { erts_fprintf(stderr, "bad number of processes %s\n", arg); erts_usage(); } } break; case 'Q': /* set maximum number of ports */ arg = get_arg(argv[i]+2, argv[i+1], &i); if (strcmp(arg, "legacy") == 0) legacy_port_tab = 1; else { errno = 0; port_tab_sz = strtol(arg, NULL, 10); if (errno != 0 || port_tab_sz < ERTS_MIN_PROCESSES || ERTS_MAX_PROCESSES < port_tab_sz) { erts_fprintf(stderr, "bad number of ports %s\n", arg); erts_usage(); } port_tab_sz_ignore_files = 1; } break; case 'S' : /* Was handled in early_init() just read past it */ (void) get_arg(argv[i]+2, argv[i+1], &i); break; case 's' : { char *estr; int res; char *sub_param = argv[i]+2; if (has_prefix("bt", sub_param)) { arg = get_arg(sub_param+2, argv[i+1], &i); res = erts_init_scheduler_bind_type_string(arg); if (res != ERTS_INIT_SCHED_BIND_TYPE_SUCCESS) { switch (res) { case ERTS_INIT_SCHED_BIND_TYPE_NOT_SUPPORTED: estr = "not supported"; break; case ERTS_INIT_SCHED_BIND_TYPE_ERROR_NO_CPU_TOPOLOGY: estr = "no cpu topology available"; break; case ERTS_INIT_SCHED_BIND_TYPE_ERROR_BAD_TYPE: estr = "invalid type"; break; default: estr = "undefined error"; break; } erts_fprintf(stderr, "setting scheduler bind type '%s' failed: %s\n", arg, estr); erts_usage(); } } else if (has_prefix("bwt", sub_param)) { arg = get_arg(sub_param+3, argv[i+1], &i); if (erts_sched_set_busy_wait_threshold(arg) != 0) { erts_fprintf(stderr, "bad scheduler busy wait threshold: %s\n", arg); erts_usage(); } VERBOSE(DEBUG_SYSTEM, ("scheduler wakup threshold: %s\n", arg)); } else if (has_prefix("cl", sub_param)) { arg = get_arg(sub_param+2, argv[i+1], &i); if (sys_strcmp("true", arg) == 0) erts_sched_compact_load = 1; else if (sys_strcmp("false", arg) == 0) erts_sched_compact_load = 0; else { erts_fprintf(stderr, "bad scheduler compact load value '%s'\n", arg); erts_usage(); } } else if (has_prefix("ct", sub_param)) { arg = get_arg(sub_param+2, argv[i+1], &i); res = erts_init_cpu_topology_string(arg); if (res != ERTS_INIT_CPU_TOPOLOGY_OK) { switch (res) { case ERTS_INIT_CPU_TOPOLOGY_INVALID_ID: estr = "invalid identifier"; break; case ERTS_INIT_CPU_TOPOLOGY_INVALID_ID_RANGE: estr = "invalid identifier range"; break; case ERTS_INIT_CPU_TOPOLOGY_INVALID_HIERARCHY: estr = "invalid hierarchy"; break; case ERTS_INIT_CPU_TOPOLOGY_INVALID_ID_TYPE: estr = "invalid identifier type"; break; case ERTS_INIT_CPU_TOPOLOGY_INVALID_NODES: estr = "invalid nodes declaration"; break; case ERTS_INIT_CPU_TOPOLOGY_MISSING_LID: estr = "missing logical identifier"; break; case ERTS_INIT_CPU_TOPOLOGY_NOT_UNIQUE_LIDS: estr = "not unique logical identifiers"; break; case ERTS_INIT_CPU_TOPOLOGY_NOT_UNIQUE_ENTITIES: estr = "not unique entities"; break; case ERTS_INIT_CPU_TOPOLOGY_MISSING: estr = "missing cpu topology"; break; default: estr = "undefined error"; break; } erts_fprintf(stderr, "bad cpu topology '%s': %s\n", arg, estr); erts_usage(); } } else if (has_prefix("pp", sub_param)) { arg = get_arg(sub_param+2, argv[i+1], &i); if (sys_strcmp(arg, "true") == 0) erts_port_parallelism = 1; else if (sys_strcmp(arg, "false") == 0) erts_port_parallelism = 0; else { erts_fprintf(stderr, "bad port parallelism scheduling hint %s\n", arg); erts_usage(); } } else if (sys_strcmp("nsp", sub_param) == 0) erts_use_sender_punish = 0; else if (has_prefix("tbt", sub_param)) { arg = get_arg(sub_param+3, argv[i+1], &i); res = erts_init_scheduler_bind_type_string(arg); if (res == ERTS_INIT_SCHED_BIND_TYPE_ERROR_BAD_TYPE) { erts_fprintf(stderr, "setting scheduler bind type '%s' failed: invalid type\n", arg); erts_usage(); } } else if (has_prefix("wct", sub_param)) { arg = get_arg(sub_param+3, argv[i+1], &i); if (erts_sched_set_wake_cleanup_threshold(arg) != 0) { erts_fprintf(stderr, "scheduler wake cleanup threshold: %s\n", arg); erts_usage(); } VERBOSE(DEBUG_SYSTEM, ("scheduler wake cleanup threshold: %s\n", arg)); } else if (has_prefix("wt", sub_param)) { arg = get_arg(sub_param+2, argv[i+1], &i); if (erts_sched_set_wakeup_other_thresold(arg) != 0) { erts_fprintf(stderr, "scheduler wakeup threshold: %s\n", arg); erts_usage(); } VERBOSE(DEBUG_SYSTEM, ("scheduler wakeup threshold: %s\n", arg)); } else if (has_prefix("ws", sub_param)) { arg = get_arg(sub_param+2, argv[i+1], &i); if (erts_sched_set_wakeup_other_type(arg) != 0) { erts_fprintf(stderr, "scheduler wakeup strategy: %s\n", arg); erts_usage(); } VERBOSE(DEBUG_SYSTEM, ("scheduler wakeup threshold: %s\n", arg)); } else if (has_prefix("ss", sub_param)) { /* suggested stack size (Kilo Words) for scheduler threads */ arg = get_arg(sub_param+2, argv[i+1], &i); erts_sched_thread_suggested_stack_size = atoi(arg); if ((erts_sched_thread_suggested_stack_size < ERTS_SCHED_THREAD_MIN_STACK_SIZE) || (erts_sched_thread_suggested_stack_size > ERTS_SCHED_THREAD_MAX_STACK_SIZE)) { erts_fprintf(stderr, "bad stack size for scheduler threads %s\n", arg); erts_usage(); } VERBOSE(DEBUG_SYSTEM, ("suggested scheduler thread stack size %d kilo words\n", erts_sched_thread_suggested_stack_size)); } else if (has_prefix("fwi", sub_param)) { long val; arg = get_arg(sub_param+3, argv[i+1], &i); errno = 0; val = strtol(arg, NULL, 10); if (errno != 0 || val < 0) { erts_fprintf(stderr, "bad scheduler forced wakeup " "interval %s\n", arg); erts_usage(); } #ifdef ERTS_SMP erts_runq_supervision_interval = val; #endif } else { erts_fprintf(stderr, "bad scheduling option %s\n", argv[i]); erts_usage(); } break; } case 't': /* set atom table size */ arg = get_arg(argv[i]+2, argv[i+1], &i); errno = 0; erts_atom_table_size = strtol(arg, NULL, 10); if (errno != 0 || erts_atom_table_size < MIN_ATOM_TABLE_SIZE || erts_atom_table_size > MAX_ATOM_TABLE_SIZE) { erts_fprintf(stderr, "bad atom table size %s\n", arg); erts_usage(); } VERBOSE(DEBUG_SYSTEM, ("setting maximum number of atoms to %d\n", erts_atom_table_size)); break; case 'T' : arg = get_arg(argv[i]+2, argv[i+1], &i); errno = 0; erts_modified_timing_level = atoi(arg); if ((erts_modified_timing_level == 0 && errno != 0) || erts_modified_timing_level < 0 || erts_modified_timing_level >= ERTS_MODIFIED_TIMING_LEVELS) { erts_fprintf(stderr, "bad modified timing level %s\n", arg); erts_usage(); } else { VERBOSE(DEBUG_SYSTEM, ("using modified timing level %d\n", erts_modified_timing_level)); } break; case 'R': { /* set compatibility release */ int this_rel; arg = get_arg(argv[i]+2, argv[i+1], &i); erts_compat_rel = atoi(arg); this_rel = this_rel_num(); if (erts_compat_rel < this_rel - 2 || this_rel < erts_compat_rel) { erts_fprintf(stderr, "bad compatibility release number %s\n", arg); erts_usage(); } switch (erts_compat_rel) { /* Currently no compat features... */ default: break; } break; } case 'A': /* Was handled in early init just read past it */ (void) get_arg(argv[i]+2, argv[i+1], &i); break; case 'a': /* suggested stack size (Kilo Words) for threads in thread pool */ arg = get_arg(argv[i]+2, argv[i+1], &i); erts_async_thread_suggested_stack_size = atoi(arg); if ((erts_async_thread_suggested_stack_size < ERTS_ASYNC_THREAD_MIN_STACK_SIZE) || (erts_async_thread_suggested_stack_size > ERTS_ASYNC_THREAD_MAX_STACK_SIZE)) { erts_fprintf(stderr, "bad stack size for async threads %s\n", arg); erts_usage(); } VERBOSE(DEBUG_SYSTEM, ("suggested async-thread stack size %d kilo words\n", erts_async_thread_suggested_stack_size)); break; case 'r': { char *sub_param = argv[i]+2; if (has_prefix("g", sub_param)) { get_arg(sub_param+1, argv[i+1], &i); /* already handled */ } else { erts_ets_realloc_always_moves = 1; } break; } case 'c': if (argv[i][2] == 0) { /* -c: documented option */ erts_disable_tolerant_timeofday = 1; } #ifdef ERTS_OPCODE_COUNTER_SUPPORT else if (argv[i][2] == 'i') { /* -ci: undcoumented option*/ count_instructions = 1; } #endif break; case 'W': arg = get_arg(argv[i]+2, argv[i+1], &i); switch (arg[0]) { case 'i': erts_error_logger_warnings = am_info; break; case 'w': erts_error_logger_warnings = am_warning; break; case 'e': /* The default */ erts_error_logger_warnings = am_error; default: erts_fprintf(stderr, "unrecognized warning_map option %s\n", arg); erts_usage(); } break; case 'z': { char *sub_param = argv[i]+2; int new_limit; if (has_prefix("dbbl", sub_param)) { arg = get_arg(sub_param+4, argv[i+1], &i); new_limit = atoi(arg); if (new_limit < 1 || INT_MAX/1024 < new_limit) { erts_fprintf(stderr, "Invalid dbbl limit: %d\n", new_limit); erts_usage(); } else { erts_dist_buf_busy_limit = new_limit*1024; } } else { erts_fprintf(stderr, "bad -z option %s\n", argv[i]); erts_usage(); } break; } default: erts_fprintf(stderr, "%s unknown flag %s\n", argv[0], argv[i]); erts_usage(); } i++; } /* Output format on windows for sprintf defaults to three exponents. * We use two-exponent to mimic normal sprintf behaviour. */ #if defined(__WIN32__) && defined(_TWO_DIGIT_EXPONENT) _set_output_format(_TWO_DIGIT_EXPONENT); #endif /* Restart will not reinstall the break handler */ #ifdef __WIN32__ if (ignore_break) erts_set_ignore_break(); else if (replace_intr) erts_replace_intr(); else init_break_handler(); #else if (ignore_break) erts_set_ignore_break(); else if (have_break_handler) init_break_handler(); if (replace_intr) erts_replace_intr(); #endif boot_argc = argc - i; /* Number of arguments to init */ boot_argv = &argv[i]; erl_init(ncpu, proc_tab_sz, legacy_proc_tab, port_tab_sz, port_tab_sz_ignore_files, legacy_port_tab); load_preloaded(); erts_end_staging_code_ix(); erts_commit_staging_code_ix(); erts_initialized = 1; erl_first_process_otp("otp_ring0", NULL, 0, boot_argc, boot_argv); #ifdef ERTS_SMP erts_start_schedulers(); /* Let system specific code decide what to do with the main thread... */ erts_sys_main_thread(); /* May or may not return! */ #else erts_thr_set_main_status(1, 1); #if ERTS_USE_ASYNC_READY_Q erts_get_scheduler_data()->aux_work_data.async_ready.queue = erts_get_async_ready_queue(1); #endif set_main_stack_size(); process_main(); #endif }
static int textread(register Dssfile_t* file, Dssrecord_t* record, Dssdisc_t* disc) { register Cxvalue_t* data = (Cxvalue_t*)file->data; register Text_t* text = (Text_t*)file->dss->meth->data; register char* s; register char* f; register int c; char* t; int num; int q; Ipaddr_t a; if (!(s = sfgetr(file->io, '\n', 1))) return 0; num = 0; f = text->format; for (;;) { switch (c = *f++) { case 0: break; case ' ': while (*s == ' ' || *s == '\t') s++; break; case '%': switch (c = *f++) { case 'h': case 'l': q = c; c = *f++; break; default: q = 0; break; } switch (c) { case 0: f--; continue; case '%': if (*s++ != c) s = null; continue; case 'c': if (data[num].number = *s) s++; num++; break; case 'd': c = 10; goto number; case 'i': if (!*s) data[num].number = 0; else { strtoip4(s, &t, &a, NiL); data[num].number = a; s = t; } num++; break; case 'n': case 'u': c = 0; goto number; case 'o': c = 8; goto number; case 'x': c = 16; number: if (!*s) data[num].number = 0; else { data[num].number = strtol(s, &t, c); s = t; } num++; break; case 'f': case 'g': if (!*s) data[num].number = 0; else { data[num].number = strtod(s, &t); s = t; } num++; break; case 's': if (q = *f) f++; if (!*s) { data[num].string.data = null; data[num].string.size = 0; } else s = lextok(s, q, &data[num].string); num++; break; case 't': if (!*s) data[num].number = 0; else { data[num].number = tmdate(s, &t, NiL); if (*t && *t != *f && *t != '\n') data[num].number = strtol(s, &t, 0); s = t; } num++; break; } continue; case '\n': break; default: if (*s++ != c) s = null; continue; } break; } record->data = data; return 1; }
static int parse_options( int argc, char *argv[], parsed_options_t *settings ) { int c, index; int retval; char *version; struct option options[] = { { "iobase", required_argument, NULL, 'b' }, { "device-file", required_argument, NULL, 'c' }, { "dma", required_argument, NULL, 'd' }, { "file", required_argument, NULL, 'f' }, { "help", no_argument, NULL, 'h' }, { "init-data", required_argument, NULL, 'I' }, { "irq", required_argument, NULL, 'i' }, { "pci-slot", required_argument, NULL, 'l' }, { "minor", required_argument, NULL, 'm' }, { "offline", no_argument, NULL, 'o' }, { "pad", required_argument, NULL, 'p' }, { "sad", required_argument, NULL, 's' }, { "board-type", required_argument, NULL, 't' }, { "pci-bus", required_argument, NULL, 'u' }, { "version", no_argument, NULL, 'v' }, { "no-ifc", no_argument, &settings->assert_ifc, 0 }, { "ifc", no_argument, &settings->assert_ifc, 1 }, { "no-sre", no_argument, &settings->assert_remote_enable, 0 }, { "sre", no_argument, &settings->assert_remote_enable, 1 }, { "no-system-controller", no_argument, &settings->is_system_controller, 0 }, { "system-controller", no_argument, &settings->is_system_controller, 1 }, { 0 }, }; memset(settings, 0, sizeof(parsed_options_t)); settings->irq = -1; settings->iobase = (unsigned long)-1; settings->dma = -1; settings->pci_bus = -1; settings->pci_slot = -1; settings->pad = -1; settings->sad = -1; settings->assert_ifc = 1; settings->assert_remote_enable = 1; settings->is_system_controller = -1; while( 1 ) { c = getopt_long(argc, argv, "b:c:d:f:hi:I:l:m:op:s:t:u:v", options, &index); if( c == -1 ) break; switch( c ) { case 0: break; case 'b': settings->iobase = strtol( optarg, NULL, 0 ); break; case 'c' : free(settings->config_file); settings->device_file = strdup( optarg ); break; case 'd': settings->dma = strtol( optarg, NULL, 0 ); break; case 'f': free(settings->config_file); settings->config_file = strdup( optarg ); break; case 'h': help(); exit( 0 ); break; case 'I': retval = load_init_data(settings, optarg); if(retval < 0) return retval; break; case 'i': settings->irq = strtol( optarg, NULL, 0 ); break; case 'l': settings->pci_slot = strtol( optarg, NULL, 0 ); break; case 'm': settings->minor = strtol( optarg, NULL, 0 ); break; case 'o': settings->offline = 1; break; case 'p': settings->pad = strtol( optarg, NULL, 0 ); break; case 's': settings->sad = strtol( optarg, NULL, 0 ); settings->sad -= sad_offset; break; case 't': free(settings->board_type); settings->board_type = strdup( optarg ); break; case 'u': settings->pci_bus = strtol( optarg, NULL, 0 ); break; case 'v': ibvers(&version); printf("linux-gpib version = %s\n",version); exit(0); break; default: help(); exit(1); } } if(settings->device_file) { struct stat file_stats; if( stat( settings->device_file, &file_stats ) < 0 ) { fprintf(stderr, "Failed to get file information on file \"%s\".\n", settings->device_file); perror(__FUNCTION__); return -errno; } if(S_ISCHR(file_stats.st_mode) == 0) { fprintf(stderr, "The device file \"%s\" is not a character device.\n", settings->device_file); return -EINVAL; } settings->minor = minor( file_stats.st_rdev ); }else { if(asprintf(&settings->device_file , "/dev/gpib%i", settings->minor) < 0) { return -ENOMEM; } } return 0; }
static int php_version_compare(const char *orig_ver1, const char *orig_ver2) { char *ver1; char *ver2; char *p1, *p2, *n1, *n2; long l1, l2; int compare = 0; if (!*orig_ver1 || !*orig_ver2) { if (!*orig_ver1 && !*orig_ver2) { return 0; } else { return *orig_ver1 ? 1 : -1; } } if (orig_ver1[0] == '#') { ver1 = strdup(orig_ver1); } else { ver1 = php_canonicalize_version(orig_ver1); } if (orig_ver2[0] == '#') { ver2 = strdup(orig_ver2); } else { ver2 = php_canonicalize_version(orig_ver2); } p1 = n1 = ver1; p2 = n2 = ver2; while (*p1 && *p2 && n1 && n2) { if ((n1 = strchr(p1, '.')) != NULL) { *n1 = '\0'; } if ((n2 = strchr(p2, '.')) != NULL) { *n2 = '\0'; } if (isdigit(*p1) && isdigit(*p2)) { /* compare element numerically */ l1 = strtol(p1, NULL, 10); l2 = strtol(p2, NULL, 10); compare = sign(l1 - l2); } else if (!isdigit(*p1) && !isdigit(*p2)) { /* compare element names */ compare = compare_special_version_forms(p1, p2); } else { /* mix of names and numbers */ if (isdigit(*p1)) { compare = compare_special_version_forms("#N#", p2); } else { compare = compare_special_version_forms(p1, "#N#"); } } if (compare != 0) { break; } if (n1 != NULL) { p1 = n1 + 1; } if (n2 != NULL) { p2 = n2 + 1; } } if (compare == 0) { if (n1 != NULL) { if (isdigit(*p1)) { compare = 1; } else { compare = php_version_compare(p1, "#N#"); } } else if (n2 != NULL) { if (isdigit(*p2)) { compare = -1; } else { compare = php_version_compare("#N#", p2); } } } free(ver1); free(ver2); return compare; }
int sscan_list(int *list[], const char *str, const char *listname) { /*this routine scans a string of the form 1,3-6,9 and returns the selected numbers (in this case 1 3 4 5 6 9) in NULL-terminated array of integers. memory for this list will be allocated in this routine -- sscan_list expects *list to be a NULL-Pointer listname is a string used in the errormessage*/ int i, istep; char c; char *pos, *startpos, *step; int n = strlen(str); /*enums to define the different lexical stati */ enum { sBefore, sNumber, sMinus, sRange, sZero, sSmaller, sError, sSteppedRange }; int status = sBefore; /*status of the deterministic automat to scan str */ int number = 0; int end_number = 0; char *start = NULL; /*holds the string of the number behind a ','*/ char *end = NULL; /*holds the string of the number behind a '-' */ int nvecs = 0; /* counts the number of vectors in the list*/ step = NULL; snew(pos, n+4); startpos = pos; strcpy(pos, str); pos[n] = ','; pos[n+1] = '1'; pos[n+2] = '\0'; *list = NULL; while ((c = *pos) != 0) { switch (status) { /* expect a number */ case sBefore: if (isdigit(c)) { start = pos; status = sNumber; break; } else { status = sError; } break; /* have read a number, expect ',' or '-' */ case sNumber: if (c == ',') { /*store number*/ srenew(*list, nvecs+1); (*list)[nvecs++] = number = strtol(start, NULL, 10); status = sBefore; if (number == 0) { status = sZero; } break; } else if (c == '-') { status = sMinus; break; } else if (isdigit(c)) { break; } else { status = sError; } break; /* have read a '-' -> expect a number */ case sMinus: if (isdigit(c)) { end = pos; status = sRange; break; } else { status = sError; } break; case sSteppedRange: if (isdigit(c)) { if (step) { status = sError; break; } else { step = pos; } status = sRange; break; } else { status = sError; } break; /* have read the number after a minus, expect ',' or ':' */ case sRange: if (c == ',') { /*store numbers*/ end_number = strtol(end, NULL, 10); number = strtol(start, NULL, 10); status = sBefore; if (number == 0) { status = sZero; break; } if (end_number <= number) { status = sSmaller; break; } srenew(*list, nvecs+end_number-number+1); if (step) { istep = strtol(step, NULL, 10); step = NULL; } else { istep = 1; } for (i = number; i <= end_number; i += istep) { (*list)[nvecs++] = i; } break; } else if (c == ':') { status = sSteppedRange; break; } else if (isdigit(c)) { break; } else { status = sError; } break; /* format error occured */ case sError: gmx_fatal(FARGS, "Error in the list of eigenvectors for %s at pos %d with char %c", listname, pos-startpos, *(pos-1)); break; /* logical error occured */ case sZero: gmx_fatal(FARGS, "Error in the list of eigenvectors for %s at pos %d: eigenvector 0 is not valid", listname, pos-startpos); break; case sSmaller: gmx_fatal(FARGS, "Error in the list of eigenvectors for %s at pos %d: second index %d is not bigger than %d", listname, pos-startpos, end_number, number); break; } ++pos; /* read next character */ } /*scanner has finished */ /* append zero to list of eigenvectors */ srenew(*list, nvecs+1); (*list)[nvecs] = 0; sfree(startpos); return nvecs; } /*sscan_list*/
static int number_callback(const struct option *opt, const char *arg, int unset) { *(int *)opt->value = strtol(arg, NULL, 10); return 0; }
/**************************************************************************** * This function prompts the user for a positive integer. It reports * whether or not this number is a perfect square. Additionally, it * prints the perfect squares immediately before and after this * number. See requirement #2 in the assignment specification ****************************************************************************/ void perfectSquares(int *optionStats) { int userNum; char *p; char buffer[7 + EXTRA_SPACES]; int divNum; int closestSquare; char* prompt = "Please enter a positive integer ( 1 - 1000000): "; printf("Perfect Squares \n ----------------- \n\n"); getString(buffer, MAX_INT_LENGTH, prompt); if ( buffer[0] == '\0' ) { printf("Exiting to Main Menu... \n \n"); return; } userNum = strtol(buffer, &p, 10); if ((buffer[0] != '\n') && (*p == '\n' || *p == '\0')) { /* VALIDATION: Range validation*/ if ( (userNum < 1000000) && (userNum > 0) ) { for (divNum=1; divNum <= userNum; divNum++) { if (divNum == (userNum / divNum)) { if ((divNum*divNum) == userNum) { printf("'%d' is a perfect square: %d * %d \n \n", userNum, divNum, divNum); return; } } else if ((userNum-1) == divNum) { printf("'%d' is not a perfect Square.\n", userNum); /*retreieve closest square roots */ /* issues occuring when using 27 as a square root. FIX!!!!!!! */ divNum = 1; closestSquare = divNum * divNum; while (closestSquare <( (userNum - divNum)-1)) { if ((divNum * divNum) > userNum) break; divNum++; closestSquare = divNum * divNum; } printf("'%d' is the perfect square before. %d * %d \n", closestSquare, divNum, divNum); divNum++; printf("'%d' is the perfect square root after. %d * %d \n \n",divNum * divNum, divNum, divNum); (optionStats[0])++; return; } } } else { printf("Invalid range \n"); } } else { printf("Invalid Number \n"); return; /*need to change to reprompt for input*/ } }
int main(int argc, char **argv) { // IMPORTANT: This call to tiLogging_Init() MUST BE DONE FIRST. // One thing it does is changes the buffering of stdout to line-based, // and that works ONLY if the stream has not been used yet, so we // MUST NOT printf/log anything before calling it... tiLogging_Init(NULL); LOG_INFO("Starting...\n"); // Return value for main int ret = 0; consoleInput.latestCh = ' '; consoleInput.handle = RTI_MAIN_INPUT_RELEASED; // setup filedescriptor for stdin fds[0].fd = fileno(stdin); fds[0].events = POLLIN; parse_opts(argc, argv); // Initialize shared semaphore. Must happen before program begins execution sem_init(&eventSem,0,1); // FILE *tmpFile; if ((ret = NPI_ClientInit(device)) != NPI_LNX_SUCCESS) { LOG_FATAL("Failed to start RTI library module, device; %s\n", device); print_usage(argv[0]); return ret; } // Get port from device char *pDevice = (char *)device; char *tmpStr = strtok(pDevice, ":"); tmpStr = strtok(NULL, ":"); connectedPort = strtol(tmpStr, NULL, 10); // Toggle Timer Print on Server state variable //Start RTI thread, management of RTI command in separate thread. if ((ret = SimpleAppInit(mode, SIMPLE_App_threadId)) != 0) { return ret; } LOG_INFO("Starting timer thread\n"); //Start RTI timer thread, management of timer in separate thread. if ((ret = timer_init(RTI_main_threadId_tblSize)) != 0) { LOG_FATAL("Failed to start timer thread. Exiting..."); return ret; } //first Menu will be display at the end of the RNP initialization. int pollRet; //MANAGE DISPLAY HERE while (1) { //Wait for Display Mutex release before displaying anything. //pthread_mutex_lock(&appDisplayMutex); //pthread_mutex_unlock(&appDisplayMutex); //Check Display buffer, if not empty display one element // Check for input characters, timeout after 500ms pollRet = poll(fds, 1, 500); if ((pollRet == 1) && (consoleInput.handle == RTI_MAIN_INPUT_RELEASED)) { // consoleInput.latestCh = getchar(); fgets(consoleInput.latestStr, sizeof(consoleInput.latestStr), stdin); // Remove \n character from string char* p; if ( (p= strchr(consoleInput.latestStr, '\n')) != NULL) *p = '\0'; consoleInput.latestCh = consoleInput.latestStr[0]; if (consoleInput.latestCh == 'q') { ret = 0; break; } // Do not act on -1, . and new line (\n) if ( (consoleInput.latestCh != -1) && (consoleInput.latestCh != '.') && (consoleInput.latestCh != '\n') ) { // Indicate to application thread that the input is ready consoleInput.handle = RTI_MAIN_INPUT_READY; // Release resources waiting for this event if (sem_post(&eventSem) < 0) { LOG_ERROR("[MAIN] Failed to post semaphore %p\n", &eventSem); } } // LOG_DEBUG("Character read: \t%c, int: %d\n", consoleInput.latestCh, // consoleInput.latestCh); // LOG_DEBUG("String read: \t%s\n", consoleInput.latestStr, // consoleInput.latestStr); } // LOG_DEBUG("poll returned: %d; console handle: %d\n", pollRet, consoleInput.handle); } // Destroy semaphores sem_destroy(&eventSem); NPI_ClientClose(); return ret; }
static int cmd_dump(PROGRAMMER * pgm, struct avrpart * p, int argc, char * argv[]) { static char prevmem[128] = {0}; char * e; unsigned char * buf; int maxsize; unsigned long i; static unsigned long addr=0; static int len=64; AVRMEM * mem; char * memtype = NULL; int rc; if (!((argc == 2) || (argc == 4))) { avrdude_message(MSG_INFO, "Usage: dump <memtype> [<addr> <len>]\n"); return -1; } memtype = argv[1]; if (strncmp(prevmem, memtype, strlen(memtype)) != 0) { addr = 0; len = 64; strncpy(prevmem, memtype, sizeof(prevmem)-1); prevmem[sizeof(prevmem)-1] = 0; } mem = avr_locate_mem(p, memtype); if (mem == NULL) { avrdude_message(MSG_INFO, "\"%s\" memory type not defined for part \"%s\"\n", memtype, p->desc); return -1; } if (argc == 4) { addr = strtoul(argv[2], &e, 0); if (*e || (e == argv[2])) { avrdude_message(MSG_INFO, "%s (dump): can't parse address \"%s\"\n", progname, argv[2]); return -1; } len = strtol(argv[3], &e, 0); if (*e || (e == argv[3])) { avrdude_message(MSG_INFO, "%s (dump): can't parse length \"%s\"\n", progname, argv[3]); return -1; } } maxsize = mem->size; if (addr >= maxsize) { if (argc == 2) { /* wrap around */ addr = 0; } else { avrdude_message(MSG_INFO, "%s (dump): address 0x%05lx is out of range for %s memory\n", progname, addr, mem->desc); return -1; } } /* trim len if nessary to not read past the end of memory */ if ((addr + len) > maxsize) len = maxsize - addr; buf = malloc(len); if (buf == NULL) { avrdude_message(MSG_INFO, "%s (dump): out of memory\n", progname); return -1; } for (i=0; i<len; i++) { rc = pgm->read_byte(pgm, p, mem, addr+i, &buf[i]); if (rc != 0) { avrdude_message(MSG_INFO, "error reading %s address 0x%05lx of part %s\n", mem->desc, addr+i, p->desc); if (rc == -1) avrdude_message(MSG_INFO, "read operation not supported on memory type \"%s\"\n", mem->desc); return -1; } } hexdump_buf(stdout, addr, buf, len); fprintf(stdout, "\n"); free(buf); addr = addr + len; return 0; }
void parse_args(int argc, char *argv[]) { char c; char *progname = argv[0]; int i; size_t len; while((c = getopt(argc, argv, "hl:s:o:")) != -1) { switch(c) { case 'h': usage(stdout, progname); exit(EX_OK); break; case 'l': if ((dlt = strtol(optarg, NULL, 0)) == 0 && errno != 0) { fprintf(stderr, "Failed to parse %s: %s\n", optarg, strerror(errno)); exit(EX_USAGE); } break; case 's': if ((dlt = strtol(optarg, NULL, 0)) == 0 && errno != 0) { fprintf(stderr, "Failed to parse %s: %s\n", optarg, strerror(errno)); exit(EX_USAGE); } break; case 'o': switch(optarg[0]) { case 'r': format = RAW; break; case 'h': format = HEXSTRING; break; case 'n': format = NG_BPF; break; default: fprintf(stderr, "Unknown format: %c\n", optarg[0]); usage(stderr, progname); exit(EX_USAGE); break; } break; default: usage(stderr, progname); exit(EX_USAGE); break; } } argc -= optind; argv += optind; if (argc == 0) { fprintf(stderr, "Expression expected\n"); usage(stderr, progname); exit(EX_USAGE); } len = argc; for(i = 0; i < argc; i++) len += strlen(argv[i]); expr = malloc(len); if (expr == NULL) exit(EX_SOFTWARE); expr[0] = '\0'; strcat(expr, argv[0]); for(i = 1; i < argc; i++) { strcat(expr, " "); strcat(expr, argv[i]); } }
/** * Parse the pattern part of a leaf. */ static int c2_parse_pattern(session_t *ps, const char *pattern, int offset, c2_ptr_t *presult) { c2_l_t * const pleaf = presult->l; // Exists operator cannot have pattern if (!pleaf->op) return offset; C2H_SKIP_SPACES(); char *endptr = NULL; // Check for boolean patterns if (!strcmp_wd("true", &pattern[offset])) { pleaf->ptntype = C2_L_PTINT; pleaf->ptnint = true; offset += strlen("true"); } else if (!strcmp_wd("false", &pattern[offset])) { pleaf->ptntype = C2_L_PTINT; pleaf->ptnint = false; offset += strlen("false"); } // Check for integer patterns else if (pleaf->ptnint = strtol(pattern + offset, &endptr, 0), pattern + offset != endptr) { pleaf->ptntype = C2_L_PTINT; offset = endptr - pattern; // Make sure we are stopping at the end of a word if (isalnum(pattern[offset])) c2_error("Trailing characters after a numeric pattern."); } // Check for string patterns else { bool raw = false; char delim = '\0'; // String flags if ('r' == tolower(pattern[offset])) { raw = true; ++offset; C2H_SKIP_SPACES(); } // Check for delimiters if ('\"' == pattern[offset] || '\'' == pattern[offset]) { pleaf->ptntype = C2_L_PTSTRING; delim = pattern[offset]; ++offset; } if (C2_L_PTSTRING != pleaf->ptntype) c2_error("Invalid pattern type."); // Parse the string now // We can't determine the length of the pattern, so we use the length // to the end of the pattern string -- currently escape sequences // cannot be converted to a string longer than itself. char *tptnstr = malloc((strlen(pattern + offset) + 1) * sizeof(char)); char *ptptnstr = tptnstr; pleaf->ptnstr = tptnstr; for (; pattern[offset] && delim != pattern[offset]; ++offset) { // Handle escape sequences if it's not a raw string if ('\\' == pattern[offset] && !raw) { switch(pattern[++offset]) { case '\\': *(ptptnstr++) = '\\'; break; case '\'': *(ptptnstr++) = '\''; break; case '\"': *(ptptnstr++) = '\"'; break; case 'a': *(ptptnstr++) = '\a'; break; case 'b': *(ptptnstr++) = '\b'; break; case 'f': *(ptptnstr++) = '\f'; break; case 'n': *(ptptnstr++) = '\n'; break; case 'r': *(ptptnstr++) = '\r'; break; case 't': *(ptptnstr++) = '\t'; break; case 'v': *(ptptnstr++) = '\v'; break; case 'o': case 'x': { char *tstr = mstrncpy(pattern + offset + 1, 2); char *pstr = NULL; long val = strtol(tstr, &pstr, ('o' == pattern[offset] ? 8: 16)); free(tstr); if (pstr != &tstr[2] || val <= 0) c2_error("Invalid octal/hex escape sequence."); assert(val < 256 && val >= 0); *(ptptnstr++) = val; offset += 2; break; } default: c2_error("Invalid escape sequence."); } } else { *(ptptnstr++) = pattern[offset]; } } if (!pattern[offset]) c2_error("Premature end of pattern string."); ++offset; *ptptnstr = '\0'; pleaf->ptnstr = mstrcpy(tptnstr); free(tptnstr); } C2H_SKIP_SPACES(); if (!pleaf->ptntype) c2_error("Invalid pattern type."); // Check if the type is correct if (!(((C2_L_TSTRING == pleaf->type || C2_L_TATOM == pleaf->type) && C2_L_PTSTRING == pleaf->ptntype) || ((C2_L_TCARDINAL == pleaf->type || C2_L_TWINDOW == pleaf->type || C2_L_TDRAWABLE == pleaf->type) && C2_L_PTINT == pleaf->ptntype))) c2_error("Pattern type incompatible with target type."); if (C2_L_PTINT == pleaf->ptntype && pleaf->match) c2_error("Integer/boolean pattern cannot have operator qualifiers."); if (C2_L_PTINT == pleaf->ptntype && pleaf->match_ignorecase) c2_error("Integer/boolean pattern cannot have flags."); if (C2_L_PTSTRING == pleaf->ptntype && (C2_L_OGT == pleaf->op || C2_L_OGTEQ == pleaf->op || C2_L_OLT == pleaf->op || C2_L_OLTEQ == pleaf->op)) c2_error("String pattern cannot have an arithmetic operator."); return offset; }
int main_vcfcall(int argc, char *argv[]) { char *ploidy_fname = NULL, *ploidy = NULL; args_t args; memset(&args, 0, sizeof(args_t)); args.argc = argc; args.argv = argv; args.aux.prior_type = -1; args.aux.indel_frac = -1; args.aux.theta = 1.1e-3; args.aux.pref = 0.5; args.aux.min_perm_p = 0.01; args.aux.min_lrt = 1; args.flag = CF_ACGT_ONLY; args.output_fname = "-"; args.output_type = FT_VCF; args.aux.trio_Pm_SNPs = 1 - 1e-8; args.aux.trio_Pm_ins = args.aux.trio_Pm_del = 1 - 1e-9; int c; static struct option loptions[] = { {"help",0,0,'h'}, {"gvcf",1,0,'g'}, {"format-fields",1,0,'f'}, {"output",1,0,'o'}, {"output-type",1,0,'O'}, {"regions",1,0,'r'}, {"regions-file",1,0,'R'}, {"samples",1,0,'s'}, {"samples-file",1,0,'S'}, {"targets",1,0,'t'}, {"targets-file",1,0,'T'}, {"keep-alts",0,0,'A'}, {"insert-missed",0,0,'i'}, {"skip-Ns",0,0,'N'}, // now the new default {"keep-masked-refs",0,0,'M'}, {"skip-variants",1,0,'V'}, {"variants-only",0,0,'v'}, {"consensus-caller",0,0,'c'}, {"constrain",1,0,'C'}, {"multiallelic-caller",0,0,'m'}, {"pval-threshold",1,0,'p'}, {"prior",1,0,'P'}, {"chromosome-X",0,0,'X'}, {"chromosome-Y",0,0,'Y'}, {"novel-rate",1,0,'n'}, {"ploidy",1,0,1}, {"ploidy-file",1,0,2}, {0,0,0,0} }; char *tmp = NULL; while ((c = getopt_long(argc, argv, "h?o:O:r:R:s:S:t:T:ANMV:vcmp:C:XYn:P:f:ig:", loptions, NULL)) >= 0) { switch (c) { case 'g': args.flag |= CF_GVCF; args.gvcf.min_dp = strtol(optarg,&tmp,10); if ( *tmp ) error("Could not parse, expected integer argument: -g %s\n", optarg); break; case 2 : ploidy_fname = optarg; break; case 1 : ploidy = optarg; break; case 'X': ploidy = "X"; fprintf(stderr,"Warning: -X will be deprecated, please use --ploidy instead.\n"); break; case 'Y': ploidy = "Y"; fprintf(stderr,"Warning: -Y will be deprecated, please use --ploidy instead.\n"); break; case 'f': args.aux.output_tags |= parse_format_flag(optarg); break; case 'M': args.flag &= ~CF_ACGT_ONLY; break; // keep sites where REF is N case 'N': args.flag |= CF_ACGT_ONLY; break; // omit sites where first base in REF is N (the new default) case 'A': args.aux.flag |= CALL_KEEPALT; break; case 'c': args.flag |= CF_CCALL; break; // the original EM based calling method case 'i': args.flag |= CF_INS_MISSED; break; case 'v': args.aux.flag |= CALL_VARONLY; break; case 'o': args.output_fname = optarg; break; case 'O': switch (optarg[0]) { case 'b': args.output_type = FT_BCF_GZ; break; case 'u': args.output_type = FT_BCF; break; case 'z': args.output_type = FT_VCF_GZ; break; case 'v': args.output_type = FT_VCF; break; default: error("The output type \"%s\" not recognised\n", optarg); } break; case 'C': if ( !strcasecmp(optarg,"alleles") ) args.aux.flag |= CALL_CONSTR_ALLELES; else if ( !strcasecmp(optarg,"trio") ) args.aux.flag |= CALL_CONSTR_TRIO; else error("Unknown argument to -C: \"%s\"\n", optarg); break; case 'V': if ( !strcasecmp(optarg,"snps") ) args.flag |= CF_INDEL_ONLY; else if ( !strcasecmp(optarg,"indels") ) args.flag |= CF_NO_INDEL; else error("Unknown skip category \"%s\" (-S argument must be \"snps\" or \"indels\")\n", optarg); break; case 'm': args.flag |= CF_MCALL; break; // multiallelic calling method case 'p': args.aux.pref = strtod(optarg,&tmp); if ( *tmp ) error("Could not parse: --pval-threshold %s\n", optarg); break; case 'P': args.aux.theta = strtod(optarg,&tmp); if ( *tmp ) error("Could not parse, expected float argument: -P %s\n", optarg); break; case 'n': parse_novel_rate(&args,optarg); break; case 'r': args.regions = optarg; break; case 'R': args.regions = optarg; args.regions_is_file = 1; break; case 't': args.targets = optarg; break; case 'T': args.targets = optarg; args.targets_is_file = 1; break; case 's': args.samples_fname = optarg; break; case 'S': args.samples_fname = optarg; args.samples_is_file = 1; break; default: usage(&args); } } // Sanity check options and initialize if ( ploidy_fname ) args.ploidy = ploidy_init(ploidy_fname, 2); else if ( ploidy ) args.ploidy = init_ploidy(ploidy); if ( optind>=argc ) { if ( !isatty(fileno((FILE *)stdin)) ) args.bcf_fname = "-"; // reading from stdin else usage(&args); } else args.bcf_fname = argv[optind++]; if ( !ploidy_fname && !ploidy ) { fprintf(stderr,"Note: Neither --ploidy nor --ploidy-file given, assuming all sites are diploid\n"); args.ploidy = ploidy_init_string("",2); } if ( !args.ploidy ) error("Could not initialize ploidy\n"); if ( args.flag & CF_GVCF ) { // Force some flags to avoid unnecessary branching args.aux.flag &= ~CALL_KEEPALT; args.aux.flag |= CALL_VARONLY; } if ( (args.flag & CF_CCALL ? 1 : 0) + (args.flag & CF_MCALL ? 1 : 0) + (args.flag & CF_QCALL ? 1 : 0) > 1 ) error("Only one of -c or -m options can be given\n"); if ( !(args.flag & CF_CCALL) && !(args.flag & CF_MCALL) && !(args.flag & CF_QCALL) ) error("Expected -c or -m option\n"); if ( args.aux.n_perm && args.aux.ngrp1_samples<=0 ) error("Expected -1 with -U\n"); // not sure about this, please fix if ( args.aux.flag & CALL_CONSTR_ALLELES ) { if ( !args.targets ) error("Expected -t or -T with \"-C alleles\"\n"); if ( !(args.flag & CF_MCALL) ) error("The \"-C alleles\" mode requires -m\n"); } if ( args.flag & CF_INS_MISSED && !(args.aux.flag&CALL_CONSTR_ALLELES) ) error("The -i option requires -C alleles\n"); init_data(&args); while ( bcf_sr_next_line(args.aux.srs) ) { bcf1_t *bcf_rec = args.aux.srs->readers[0].buffer[0]; if ( args.samples_map ) bcf_subset(args.aux.hdr, bcf_rec, args.nsamples, args.samples_map); bcf_unpack(bcf_rec, BCF_UN_STR); // Skip unwanted sites if ( args.aux.flag & CALL_VARONLY ) { int is_ref = 0; if ( bcf_rec->n_allele==1 ) is_ref = 1; // not a variant else if ( bcf_rec->n_allele==2 ) { // second allele is mpileup's X, not a variant if ( bcf_rec->d.allele[1][0]=='X' ) is_ref = 1; else if ( bcf_rec->d.allele[1][0]=='<' && bcf_rec->d.allele[1][1]=='X' && bcf_rec->d.allele[1][2]=='>' ) is_ref = 1; else if ( bcf_rec->d.allele[1][0]=='<' && bcf_rec->d.allele[1][1]=='*' && bcf_rec->d.allele[1][2]=='>' ) is_ref = 1; } if ( is_ref ) { // gVCF output if ( args.flag & CF_GVCF ) gvcf_write(args.out_fh, &args.gvcf, args.aux.hdr, bcf_rec, 1); continue; } } if ( (args.flag & CF_INDEL_ONLY) && bcf_is_snp(bcf_rec) ) continue; // not an indel if ( (args.flag & CF_NO_INDEL) && !bcf_is_snp(bcf_rec) ) continue; // not a SNP if ( (args.flag & CF_ACGT_ONLY) && (bcf_rec->d.allele[0][0]=='N' || bcf_rec->d.allele[0][0]=='n') ) continue; // REF[0] is 'N' bcf_unpack(bcf_rec, BCF_UN_ALL); if ( args.nsex ) set_ploidy(&args, bcf_rec); // Various output modes: QCall output (todo) if ( args.flag & CF_QCALL ) { qcall(&args.aux, bcf_rec); continue; } // Calling modes which output VCFs int ret; if ( args.flag & CF_MCALL ) ret = mcall(&args.aux, bcf_rec); else ret = ccall(&args.aux, bcf_rec); if ( ret==-1 ) error("Something is wrong\n"); // gVCF output if ( args.flag & CF_GVCF ) { gvcf_write(args.out_fh, &args.gvcf, args.aux.hdr, bcf_rec, ret?0:1); continue; } // Normal output if ( (args.aux.flag & CALL_VARONLY) && ret==0 ) continue; // not a variant bcf_write1(args.out_fh, args.aux.hdr, bcf_rec); } if ( args.flag & CF_GVCF ) gvcf_write(args.out_fh, &args.gvcf, args.aux.hdr, NULL, 0); if ( args.flag & CF_INS_MISSED ) bcf_sr_regions_flush(args.aux.srs->targets); destroy_data(&args); return 0; }
/* * ::getaddrinfo */ int getaddrinfo(const char *nodename, const char *servname, const struct addrinfo *hints, struct addrinfo **res) { unsigned long ip_addr; uint8_t domain; *res = malloc(sizeof(struct addrinfo)); if (*res == NULL) { return EAI_MEMORY; } memset(*res, 0, sizeof(struct addrinfo)); (*res)->ai_addr = malloc(sizeof(struct sockaddr)); if ((*res)->ai_addr == NULL) { free(*res); return EAI_MEMORY; } memset((*res)->ai_addr, 0, sizeof(struct addrinfo)); switch (hints->ai_family) { case AF_INET: domain = SL_AF_INET; break; case AF_INET6: domain = SL_AF_INET6; break; case AF_PACKET: domain = SL_AF_PACKET; break; default: errno = EAFNOSUPPORT; free((*res)->ai_addr); free(*res); return -1; } int result = sl_NetAppDnsGetHostByName((int8_t*)nodename, strlen(nodename), &ip_addr, domain); if (result != 0) { free((*res)->ai_addr); free(*res); switch (result) { default: case SL_POOL_IS_EMPTY: return EAI_AGAIN; case SL_NET_APP_DNS_QUERY_NO_RESPONSE: case SL_NET_APP_DNS_NO_SERVER: case SL_NET_APP_DNS_QUERY_FAILED: case SL_NET_APP_DNS_MALFORMED_PACKET: case SL_NET_APP_DNS_MISMATCHED_RESPONSE: return EAI_FAIL; } } switch (hints->ai_family) { case AF_INET: { struct sockaddr_in *addr_in = (struct sockaddr_in*)(*res)->ai_addr; (*res)->ai_flags = 0; (*res)->ai_family = hints->ai_family; (*res)->ai_socktype = hints->ai_socktype; (*res)->ai_protocol = hints->ai_protocol; (*res)->ai_addrlen = sizeof(struct sockaddr_in); addr_in->sin_family = hints->ai_family; addr_in->sin_port = htons((uint16_t)strtol(servname, NULL, 0)); addr_in->sin_addr.s_addr = htonl(ip_addr); break; } case AF_INET6: case AF_PACKET: default: errno = EAFNOSUPPORT; free((*res)->ai_addr); free(*res); return -1; } return 0; }
nozzle_t nozzle_open(char *devname, size_t devname_size, const char *updownpath) { int savederrno = 0; nozzle_t nozzle = NULL; char *temp_mac = NULL; #ifdef KNET_LINUX struct ifreq ifr; #endif #ifdef KNET_BSD uint16_t i; long int nozzlenum = 0; char curnozzle[IFNAMSIZ]; #endif if (devname == NULL) { errno = EINVAL; return NULL; } if (devname_size < IFNAMSIZ) { errno = EINVAL; return NULL; } if (strlen(devname) > IFNAMSIZ) { errno = E2BIG; return NULL; } #ifdef KNET_BSD /* * BSD does not support named devices like Linux * but it is possible to force a nozzleX device number * where X is 0 to 255. */ if (strlen(devname)) { if (strncmp(devname, "tap", 3)) { errno = EINVAL; return NULL; } errno = 0; nozzlenum = strtol(devname+3, NULL, 10); if (errno) { errno = EINVAL; return NULL; } if ((nozzlenum < 0) || (nozzlenum > 255)) { errno = EINVAL; return NULL; } } #endif if (updownpath) { /* only absolute paths */ if (updownpath[0] != '/') { errno = EINVAL; return NULL; } if (strlen(updownpath) >= UPDOWN_PATH_MAX) { errno = E2BIG; return NULL; } } savederrno = pthread_mutex_lock(&config_mutex); if (savederrno) { errno = savederrno; return NULL; } if (!lib_init) { lib_cfg.head = NULL; #ifdef KNET_LINUX lib_cfg.nlsock = nl_socket_alloc(); if (!lib_cfg.nlsock) { savederrno = errno; goto out_error; } if (nl_connect(lib_cfg.nlsock, NETLINK_ROUTE) < 0) { savederrno = EBUSY; goto out_error; } lib_cfg.ioctlfd = socket(AF_INET, SOCK_STREAM, 0); #endif #ifdef KNET_BSD lib_cfg.ioctlfd = socket(AF_LOCAL, SOCK_DGRAM, 0); #endif if (lib_cfg.ioctlfd < 0) { savederrno = errno; goto out_error; } lib_init = 1; } nozzle = malloc(sizeof(struct nozzle_iface)); if (!nozzle) { savederrno = ENOMEM; goto out_error; } memset(nozzle, 0, sizeof(struct nozzle_iface)); #ifdef KNET_BSD if (!strlen(devname)) { for (i = 0; i < 256; i++) { snprintf(curnozzle, sizeof(curnozzle) - 1, "/dev/tap%u", i); nozzle->fd = open(curnozzle, O_RDWR); savederrno = errno; if (nozzle->fd > 0) { break; } } snprintf(curnozzle, sizeof(curnozzle) -1 , "tap%u", i); } else { snprintf(curnozzle, sizeof(curnozzle) - 1, "/dev/%s", devname); nozzle->fd = open(curnozzle, O_RDWR); savederrno = errno; snprintf(curnozzle, sizeof(curnozzle) - 1, "%s", devname); } if (nozzle->fd < 0) { savederrno = EBUSY; goto out_error; } strncpy(devname, curnozzle, IFNAMSIZ); strncpy(nozzle->name, curnozzle, IFNAMSIZ); #endif #ifdef KNET_LINUX if ((nozzle->fd = open("/dev/net/tun", O_RDWR)) < 0) { savederrno = errno; goto out_error; } memset(&ifr, 0, sizeof(struct ifreq)); memmove(ifname, devname, IFNAMSIZ); ifr.ifr_flags = IFF_TAP | IFF_NO_PI; if (ioctl(nozzle->fd, TUNSETIFF, &ifr) < 0) { savederrno = errno; goto out_error; } if ((strlen(devname) > 0) && (strcmp(devname, ifname) != 0)) { savederrno = EBUSY; goto out_error; } strncpy(devname, ifname, IFNAMSIZ); strncpy(nozzle->name, ifname, IFNAMSIZ); #endif nozzle->default_mtu = get_iface_mtu(nozzle); if (nozzle->default_mtu < 0) { savederrno = errno; goto out_error; } if (get_iface_mac(nozzle, &temp_mac) < 0) { savederrno = errno; goto out_error; } strncpy(nozzle->default_mac, temp_mac, 18); free(temp_mac); if (updownpath) { int len = strlen(updownpath); strcpy(nozzle->updownpath, updownpath); if (nozzle->updownpath[len-1] != '/') { nozzle->updownpath[len] = '/'; } nozzle->hasupdown = 1; } nozzle->next = lib_cfg.head; lib_cfg.head = nozzle; pthread_mutex_unlock(&config_mutex); errno = savederrno; return nozzle; out_error: destroy_iface(nozzle); pthread_mutex_unlock(&config_mutex); errno = savederrno; return NULL; }
static int outputs_integer_cb(void *params_, long long val) { #else static int outputs_integer_cb(void *params_, long val) { #endif struct outputs_json_params *params = (struct outputs_json_params*) params_; if (!strcmp(params->cur_key, "current_workspace")) { params->outputs_walk->ws = (int) val; FREE(params->cur_key); return 1; } if (!strcmp(params->cur_key, "x")) { params->outputs_walk->rect.x = (int) val; FREE(params->cur_key); return 1; } if (!strcmp(params->cur_key, "y")) { params->outputs_walk->rect.y = (int) val; FREE(params->cur_key); return 1; } if (!strcmp(params->cur_key, "width")) { params->outputs_walk->rect.w = (int) val; FREE(params->cur_key); return 1; } if (!strcmp(params->cur_key, "height")) { params->outputs_walk->rect.h = (int) val; FREE(params->cur_key); return 1; } return 0; } /* * Parse a string (name) * */ #if YAJL_MAJOR >= 2 static int outputs_string_cb(void *params_, const unsigned char *val, size_t len) { #else static int outputs_string_cb(void *params_, const unsigned char *val, unsigned int len) { #endif struct outputs_json_params *params = (struct outputs_json_params*) params_; if (!strcmp(params->cur_key, "current_workspace")) { char *copy = malloc(sizeof(const unsigned char) * (len + 1)); strncpy(copy, (const char*) val, len); copy[len] = '\0'; char *end; errno = 0; long parsed_num = strtol(copy, &end, 10); if (errno == 0 && (end && *end == '\0')) params->outputs_walk->ws = parsed_num; free(copy); FREE(params->cur_key); return 1; } if (strcmp(params->cur_key, "name")) { return 0; } char *name = malloc(sizeof(const unsigned char) * (len + 1)); strncpy(name, (const char*) val, len); name[len] = '\0'; params->outputs_walk->name = name; FREE(params->cur_key); return 1; } /* * We hit the start of a json-map (rect or a new output) * */ static int outputs_start_map_cb(void *params_) { struct outputs_json_params *params = (struct outputs_json_params*) params_; i3_output *new_output = NULL; if (params->cur_key == NULL) { new_output = malloc(sizeof(i3_output)); new_output->name = NULL; new_output->ws = 0, memset(&new_output->rect, 0, sizeof(rect)); new_output->bar = XCB_NONE; new_output->workspaces = malloc(sizeof(struct ws_head)); TAILQ_INIT(new_output->workspaces); params->outputs_walk = new_output; return 1; } return 1; } /* * We hit the end of a map (rect or a new output) * */ static int outputs_end_map_cb(void *params_) { struct outputs_json_params *params = (struct outputs_json_params*) params_; /* FIXME: What is at the end of a rect? */ i3_output *target = get_output_by_name(params->outputs_walk->name); if (target == NULL) { SLIST_INSERT_HEAD(outputs, params->outputs_walk, slist); } else { target->active = params->outputs_walk->active; target->ws = params->outputs_walk->ws; target->rect = params->outputs_walk->rect; } return 1; } /* * Parse a key. * * Essentially we just save it in the parsing-state * */ #if YAJL_MAJOR >= 2 static int outputs_map_key_cb(void *params_, const unsigned char *keyVal, size_t keyLen) { #else static int outputs_map_key_cb(void *params_, const unsigned char *keyVal, unsigned keyLen) { #endif struct outputs_json_params *params = (struct outputs_json_params*) params_; FREE(params->cur_key); params->cur_key = malloc(sizeof(unsigned char) * (keyLen + 1)); strncpy(params->cur_key, (const char*) keyVal, keyLen); params->cur_key[keyLen] = '\0'; return 1; } /* A datastructure to pass all these callbacks to yajl */ yajl_callbacks outputs_callbacks = { &outputs_null_cb, &outputs_boolean_cb, &outputs_integer_cb, NULL, NULL, &outputs_string_cb, &outputs_start_map_cb, &outputs_map_key_cb, &outputs_end_map_cb, NULL, NULL }; /* * Initiate the output-list * */ void init_outputs() { outputs = malloc(sizeof(struct outputs_head)); SLIST_INIT(outputs); } /* * Start parsing the received json-string * */ void parse_outputs_json(char *json) { struct outputs_json_params params; params.outputs_walk = NULL; params.cur_key = NULL; params.json = json; yajl_handle handle; yajl_status state; #if YAJL_MAJOR < 2 yajl_parser_config parse_conf = { 0, 0 }; handle = yajl_alloc(&outputs_callbacks, &parse_conf, NULL, (void*) ¶ms); #else handle = yajl_alloc(&outputs_callbacks, NULL, (void*) ¶ms); #endif state = yajl_parse(handle, (const unsigned char*) json, strlen(json)); /* FIXME: Propper errorhandling for JSON-parsing */ switch (state) { case yajl_status_ok: break; case yajl_status_client_canceled: #if YAJL_MAJOR < 2 case yajl_status_insufficient_data: #endif case yajl_status_error: ELOG("Could not parse outputs-reply!\n"); exit(EXIT_FAILURE); break; } yajl_free(handle); } /* * Returns the output with the given name * */ i3_output *get_output_by_name(char *name) { i3_output *walk; if (name == NULL) { return NULL; } SLIST_FOREACH(walk, outputs, slist) { if (!strcmp(walk->name, name)) { break; } } return walk; }
static int hostent_read_snapshot_func(struct hostent *ht, char *line) { StringList *sl1, *sl2; char *s, *ps, *ts; int i, rv; #ifdef DEBUG printf("1 line read from snapshot:\n%s\n", line); #endif rv = 0; i = 0; sl1 = sl2 = NULL; ps = line; memset(ht, 0, sizeof(struct hostent)); while ((s = strsep(&ps, " ")) != NULL) { switch (i) { case 0: ht->h_name = strdup(s); ATF_REQUIRE(ht->h_name != NULL); break; case 1: ht->h_addrtype = (int)strtol(s, &ts, 10); if (*ts != '\0') goto fin; break; case 2: ht->h_length = (int)strtol(s, &ts, 10); if (*ts != '\0') goto fin; break; case 3: if (sl1 == NULL) { if (strcmp(s, "(null)") == 0) return (0); sl1 = sl_init(); ATF_REQUIRE(sl1 != NULL); if (strcmp(s, "noaliases") != 0) { ts = strdup(s); ATF_REQUIRE(ts != NULL); sl_add(sl1, ts); } } else { if (strcmp(s, ":") == 0) ++i; else { ts = strdup(s); ATF_REQUIRE(ts != NULL); sl_add(sl1, ts); } } break; case 4: if (sl2 == NULL) { if (strcmp(s, "(null)") == 0) return (0); sl2 = sl_init(); ATF_REQUIRE(sl2 != NULL); if (strcmp(s, "noaddrs") != 0) { ts = calloc(1, ht->h_length); ATF_REQUIRE(ts != NULL); rv = hostent_read_snapshot_addr(s, (unsigned char *)ts, ht->h_length); sl_add(sl2, ts); if (rv != 0) goto fin; } } else { ts = calloc(1, ht->h_length); ATF_REQUIRE(ts != NULL); rv = hostent_read_snapshot_addr(s, (unsigned char *)ts, ht->h_length); sl_add(sl2, ts); if (rv != 0) goto fin; } break; default: break; } if (i != 3 && i != 4) ++i; } fin: if (sl1 != NULL) { sl_add(sl1, NULL); ht->h_aliases = sl1->sl_str; } if (sl2 != NULL) { sl_add(sl2, NULL); ht->h_addr_list = sl2->sl_str; } if ((i != 4) || (rv != 0)) { free_hostent(ht); memset(ht, 0, sizeof(struct hostent)); return (-1); } /* NOTE: is it a dirty hack or not? */ free(sl1); free(sl2); return (0); }
int run(int argc, char **argv) { args_t *args = (args_t*) calloc(1,sizeof(args_t)); args->nsites = 10; args->min_hets = 0.3; args->background = "X:60001-2699520"; static struct option loptions[] = { {"verbose",1,0,'v'}, {"ploidy",1,0,'p'}, {"nsites",1,0,'n'}, {"guess",1,0,'g'}, {"min-hets",1,0,'m'}, {"background",1,0,'b'}, {0,0,0,0} }; char c, *tmp, *ploidy_fname = NULL; while ((c = getopt_long(argc, argv, "p:n:g:m:vb:",loptions,NULL)) >= 0) { switch (c) { case 'b': if ( !strcmp("-",optarg) ) args->background = NULL; else args->background = optarg; break; case 'v': args->verbose = 1; break; case 'g': if ( !strcasecmp(optarg,"GT") ) args->guess = GUESS_GT; else if ( !strcasecmp(optarg,"PL") ) args->guess = GUESS_PL; else if ( !strcasecmp(optarg,"GL") ) args->guess = GUESS_GL; else error("The argument not recognised, expected --guess GT, --guess PL or --guess GL: %s\n", optarg); break; case 'm': args->min_hets = strtod(optarg,&tmp); if ( *tmp ) error("Unexpected argument to --min-hets: %s\n", optarg); break; case 'p': ploidy_fname = optarg; break; case 'n': args->nsites = strtol(optarg,&tmp,10); if (*tmp) error("Unexpected argument to --nsites: %s\n", optarg); break; case 'h': case '?': default: error("%s", usage()); break; } } args->sr = bcf_sr_init(); args->sr->require_index = 1; if ( !argv[0] ) error("%s", usage()); if ( !bcf_sr_add_reader(args->sr,argv[0]) ) error("Error: %s\n", bcf_sr_strerror(args->sr->errnum)); args->hdr = args->sr->readers[0].header; args->nsample = bcf_hdr_nsamples(args->hdr); args->dflt_ploidy = 2; if ( ploidy_fname ) { args->ploidy = ploidy_init(ploidy_fname, args->dflt_ploidy); if ( !args->ploidy ) error("Could not read %s\n", ploidy_fname); } else { args->ploidy = ploidy_init_string( "X 1 60000 M 1\n" "X 2699521 154931043 M 1\n" "Y 1 59373566 M 1\n" "Y 1 59373566 F 0\n", args->dflt_ploidy); } args->nsex = ploidy_nsex(args->ploidy); args->sex2ploidy = (int*) malloc(sizeof(int)*args->nsex); args->max_ploidy = ploidy_max(args->ploidy); if ( args->guess && args->max_ploidy > 2 ) error("Sorry, ploidy %d not supported with -g\n", args->max_ploidy); args->ncounts = args->nsample * ((args->max_ploidy>2 ? args->max_ploidy : 2)+1); args->counts = (int*) malloc(sizeof(int)*args->ncounts); args->bg_counts = (count_t*) calloc(args->nsample,sizeof(count_t)); args->sex2prob = (float*) calloc(args->nsample*args->nsex,sizeof(float)); int i, nseq; for (i=0; i<args->nsample*args->nsex; i++) args->sex2prob[i] = 1; if ( args->verbose && args->guess ) printf("# [1]REG\t[2]Region\t[3]Sample\t[4]Het fraction\t[5]nHet\t[6]nHom\t[7]nMissing\n"); // First get the counts from expected haploid regions regidx_t *idx = ploidy_regions(args->ploidy); char **seqs = regidx_seq_names(idx, &nseq); for (i=0; i<nseq; i++) { regitr_t itr; regidx_overlap(idx, seqs[i], 0, UINT32_MAX, &itr); while ( itr.i < itr.n ) { if ( args->guess ) itr.i += process_region_guess(args, seqs[i], &itr); else itr.i += process_region_precise(args, seqs[i], &itr); } } // Get the counts from a PAR (the background diploid region) and see if the fraction // of hets is different if ( args->guess ) sex2prob_guess(args); for (i=0; i<args->nsample; i++) { int j, jmax = 0; float max = 0, sum = 0; for (j=0; j<args->nsex; j++) { sum += args->sex2prob[i*args->nsex+j]; if ( max < args->sex2prob[i*args->nsex+j] ) { jmax = j; max = args->sex2prob[i*args->nsex+j]; } } if ( args->verbose ) printf("%s\t%s\t%f\n", args->hdr->samples[i],ploidy_id2sex(args->ploidy,jmax),args->sex2prob[i*args->nsex+jmax]/sum); else printf("%s\t%s\n", args->hdr->samples[i],ploidy_id2sex(args->ploidy,jmax)); } bcf_sr_destroy(args->sr); ploidy_destroy(args->ploidy); destroy_regs(args); free(args->sex2ploidy); free(args->counts); free(args->bg_counts); free(args->gts); free(args->pls); free(args->sex2prob); free(args); return 0; }
static NMActStageReturn apply_bonding_config (NMDevice *device) { NMConnection *connection; NMSettingBond *s_bond; int ifindex = nm_device_get_ifindex (device); const char *mode, *value; char *contents; gboolean set_arp_interval = TRUE; /* Option restrictions: * * arp_interval conflicts miimon > 0 * arp_interval conflicts [ alb, tlb ] * arp_validate needs [ active-backup ] * downdelay needs miimon * updelay needs miimon * primary needs [ active-backup, tlb, alb ] * * clearing miimon requires that arp_interval be 0, but clearing * arp_interval doesn't require miimon to be 0 */ connection = nm_device_get_connection (device); g_assert (connection); s_bond = nm_connection_get_setting_bond (connection); g_assert (s_bond); mode = nm_setting_bond_get_option_by_name (s_bond, NM_SETTING_BOND_OPTION_MODE); if (mode == NULL) mode = "balance-rr"; value = nm_setting_bond_get_option_by_name (s_bond, NM_SETTING_BOND_OPTION_MIIMON); if (value && atoi (value)) { /* clear arp interval */ set_bond_attr (device, "arp_interval", "0"); set_arp_interval = FALSE; set_bond_attr (device, "miimon", value); set_simple_option (device, "updelay", s_bond, NM_SETTING_BOND_OPTION_UPDELAY); set_simple_option (device, "downdelay", s_bond, NM_SETTING_BOND_OPTION_DOWNDELAY); } else if (!value) { /* If not given, and arp_interval is not given, default to 100 */ long int val_int; char *end; value = nm_setting_bond_get_option_by_name (s_bond, NM_SETTING_BOND_OPTION_ARP_INTERVAL); errno = 0; val_int = strtol (value ? value : "0", &end, 10); if (!value || (val_int == 0 && errno == 0 && *end == '\0')) set_bond_attr (device, "miimon", "100"); } /* The stuff after 'mode' requires the given mode or doesn't care */ set_bond_attr (device, "mode", mode); /* arp_interval not compatible with ALB, TLB */ if (g_strcmp0 (mode, "balance-alb") == 0 || g_strcmp0 (mode, "balance-tlb") == 0) set_arp_interval = FALSE; if (set_arp_interval) { set_simple_option (device, "arp_interval", s_bond, NM_SETTING_BOND_OPTION_ARP_INTERVAL); /* Just let miimon get cleared automatically; even setting miimon to * 0 (disabled) clears arp_interval. */ } value = nm_setting_bond_get_option_by_name (s_bond, NM_SETTING_BOND_OPTION_ARP_VALIDATE); /* arp_validate > 0 only valid in active-backup mode */ if ( value && g_strcmp0 (value, "0") != 0 && g_strcmp0 (value, "none") != 0 && g_strcmp0 (mode, "active-backup") == 0) set_bond_attr (device, "arp_validate", value); else set_bond_attr (device, "arp_validate", "0"); if ( g_strcmp0 (mode, "active-backup") == 0 || g_strcmp0 (mode, "balance-alb") == 0 || g_strcmp0 (mode, "balance-tlb") == 0) { value = nm_setting_bond_get_option_by_name (s_bond, NM_SETTING_BOND_OPTION_PRIMARY); set_bond_attr (device, "primary", value ? value : ""); } /* Clear ARP targets */ contents = nm_platform_master_get_option (ifindex, "arp_ip_target"); set_arp_targets (device, contents, " \n", "-"); g_free (contents); /* Add new ARP targets */ value = nm_setting_bond_get_option_by_name (s_bond, NM_SETTING_BOND_OPTION_ARP_IP_TARGET); set_arp_targets (device, value, ",", "+"); set_simple_option (device, "primary_reselect", s_bond, NM_SETTING_BOND_OPTION_PRIMARY_RESELECT); set_simple_option (device, "fail_over_mac", s_bond, NM_SETTING_BOND_OPTION_FAIL_OVER_MAC); set_simple_option (device, "use_carrier", s_bond, NM_SETTING_BOND_OPTION_USE_CARRIER); set_simple_option (device, "ad_select", s_bond, NM_SETTING_BOND_OPTION_AD_SELECT); set_simple_option (device, "xmit_hash_policy", s_bond, NM_SETTING_BOND_OPTION_XMIT_HASH_POLICY); set_simple_option (device, "resend_igmp", s_bond, NM_SETTING_BOND_OPTION_RESEND_IGMP); if ( g_strcmp0 (mode, "4") == 0 || g_strcmp0 (mode, "802.3ad") == 0) set_simple_option (device, "lacp_rate", s_bond, NM_SETTING_BOND_OPTION_LACP_RATE); return NM_ACT_STAGE_RETURN_SUCCESS; }