/* 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;
}
