char *chirp_ticket_tostring(struct chirp_ticket *ct) { size_t n; const char *s; char *result; buffer_t B; buffer_init(&B); buffer_abortonfailure(&B, 1); buffer_printf(&B, "subject \"%s\"\n", ct->subject); buffer_printf(&B, "ticket \"%s\"\n", ct->ticket); buffer_printf(&B, "expiration \"%lu\"\n", (unsigned long) ct->expiration); for(n = 0; n < ct->nrights; n++) { buffer_printf(&B, "rights \"%s\" \"%s\"\n", ct->rights[n].directory, ct->rights[n].acl); } s = buffer_tostring(&B, &n); result = xxmalloc(n + 1); memset(result, 0, n + 1); memcpy(result, s, n); buffer_free(&B); return result; }
int advertise_pool_decision_to_catalog(const char *catalog_host, int catalog_port, const char *pool_name, pid_t pid, time_t start_time, const char *decision, int workers_requested) { char address[DATAGRAM_ADDRESS_MAX]; char owner[USERNAME_MAX]; buffer_t B; const char *text; size_t text_size; static time_t last_update_time = 0; if(time(0) - last_update_time < WORK_QUEUE_CATALOG_POOL_UPDATE_INTERVAL) return 1; if(!outgoing_datagram) { outgoing_datagram = datagram_create(0); if(!outgoing_datagram) { fprintf(stderr, "Couldn't create outgoing udp port, thus work queue master info won't be sent to the catalog server!\n"); return 0; } } if(!username_get(owner)) { strcpy(owner,"unknown"); } // port = MAX_TCP_PORT + process id, this is for the catalog server to // distinguish the worker pools from the same host. See make_hash_key() // function in catalog_server.c INT64_T port = 65535 + pid; buffer_init(&B); buffer_abortonfailure(&B, 1); buffer_printf(&B, "type wq_pool\npool_name %s\nport %" PRId64 "\nstarttime %llu\ndecision %s\nworkers_requested %d\nowner %s\nlifetime %d", pool_name, port, (unsigned long long) start_time, decision, workers_requested, owner, WORK_QUEUE_CATALOG_POOL_AD_LIFETIME); text = buffer_tostring(&B, &text_size); debug(D_WQ, "Pool AD: \n%s\n", text); if(domain_name_cache_lookup(catalog_host, address)) { debug(D_WQ, "Sending the pool decision to the catalog server at %s:%d ...", catalog_host, catalog_port); datagram_send(outgoing_datagram, text, text_size, address, catalog_port); } buffer_free(&B); last_update_time = time(0); return 1; }
struct jx * jx_format( const char *fmt, ... ) { va_list va; struct jx *j; buffer_t B[1]; char *str; buffer_init(B); buffer_abortonfailure(B, 1); va_start(va, fmt); buffer_putvfstring(B, fmt, va); va_end(va); buffer_dup(B, &str); buffer_free(B); j = jx_create(JX_STRING); j->u.string_value = str; return j; }
/* * Based on opengroup.org's definition of the Shell Command Language (also gnu's) * In section 2.2.3 on Double-Quoted Strings, it indicates you only need to * escape dollar sign, backtick, and backslash. I also escape double quote as * we are adding and exterior double quote around the string. * * [ $ \ ` " ] Are always escaped. * */ char *string_escape_shell( const char *str ) { buffer_t B[1]; buffer_init(B); buffer_abortonfailure(B, 1); const char *s; buffer_putliteral(B,"\""); for(s=str;*s;s++) { if(*s=='"' || *s=='\\' || *s=='$' || *s=='`') buffer_putliteral(B,"\\"); buffer_putlstring(B,s,1); } buffer_putliteral(B,"\""); char *result; buffer_dup(B,&result); buffer_free(B); return result; }
static int ticket_read(char *ticket_filename, struct chirp_ticket *ct) { buffer_t B; CHIRP_FILE *tf = cfs_fopen(ticket_filename, "r"); if(!tf) return 0; buffer_init(&B); buffer_abortonfailure(&B, 1); if(!cfs_freadall(tf, &B)) { cfs_fclose(tf); return 0; } cfs_fclose(tf); int result = chirp_ticket_read(buffer_tostring(&B, NULL), ct); buffer_free(&B); return result; }
int nvpair_print_alloc(struct nvpair *n, char **text) { size_t needed; char *key; void *value; buffer_t b; buffer_init(&b); buffer_abortonfailure(&b, 0); hash_table_firstkey(n->table); while(hash_table_nextkey(n->table, &key, &value)) { buffer_printf(&b, "%s %s\n", key, (char *) value); } *text = xxstrdup(buffer_tostring(&b, &needed)); buffer_free(&b); return needed; }
CHIRP_FILE *cfs_fopen(const char *path, const char *mode) { CHIRP_FILE *file; INT64_T fd; INT64_T flags = 0; if(strchr(mode, '+')) { errno = ENOTSUP; return 0; } if(strchr(mode, 'r')) flags |= O_RDONLY; else if(strchr(mode, 'w')) flags |= O_WRONLY | O_CREAT | O_TRUNC; else if(strchr(mode, 'a')) flags |= O_APPEND | O_CREAT; else { errno = EINVAL; return 0; } fd = cfs->open(path, flags, 0600); if(fd == -1) return NULL; file = xxmalloc(sizeof(CHIRP_FILE)); file->type = CFS; buffer_init(&file->f.cfile.B); buffer_abortonfailure(&file->f.cfile.B, 1); file->f.cfile.fd = fd; file->type = CFS; file->f.cfile.offset = file->f.cfile.read_n = 0; file->f.cfile.error = 0; memset(file->f.cfile.read, '\0', sizeof(file->f.cfile.read)); return file; }
struct link *http_query_size_via_proxy(const char *proxy, const char *urlin, const char *action, INT64_T * size, time_t stoptime, int cache_reload) { char url[HTTP_LINE_MAX]; char newurl[HTTP_LINE_MAX]; char line[HTTP_LINE_MAX]; char addr[LINK_ADDRESS_MAX]; struct link *link; int save_errno; int response; char actual_host[HTTP_LINE_MAX]; int actual_port; *size = 0; url_encode(urlin, url, sizeof(url)); if(proxy && !strcmp(proxy, "DIRECT")) proxy = 0; if(proxy) { int fields = sscanf(proxy, "http://%[^:]:%d", actual_host, &actual_port); if(fields == 2) { /* host and port are good */ } else if(fields == 1) { actual_port = HTTP_PORT; } else { debug(D_HTTP, "invalid proxy syntax: %s", proxy); return 0; } } else { int fields = sscanf(url, "http://%[^:]:%d", actual_host, &actual_port); if(fields != 2) { fields = sscanf(url, "http://%[^/]", actual_host); if(fields == 1) { actual_port = HTTP_PORT; } else { debug(D_HTTP, "malformed url: %s", url); return 0; } } } debug(D_HTTP, "connect %s port %d", actual_host, actual_port); if(!domain_name_lookup(actual_host, addr)) return 0; link = link_connect(addr, actual_port, stoptime); if(!link) { errno = ECONNRESET; return 0; } { buffer_t B; buffer_init(&B); buffer_abortonfailure(&B, 1); buffer_printf(&B, "%s %s HTTP/1.1\r\n", action, url); if(cache_reload) buffer_putliteral(&B, "Cache-Control: max-age=0\r\n"); buffer_putliteral(&B, "Connection: close\r\n"); buffer_printf(&B, "Host: %s\r\n", actual_host); if(getenv("HTTP_USER_AGENT")) buffer_printf(&B, "User-Agent: Mozilla/5.0 (compatible; CCTools %d.%d.%s Parrot; http://www.nd.edu/~ccl/ %s)\r\n", CCTOOLS_VERSION_MAJOR, CCTOOLS_VERSION_MINOR, CCTOOLS_VERSION_MICRO, getenv("HTTP_USER_AGENT")); else buffer_printf(&B, "User-Agent: Mozilla/5.0 (compatible; CCTools %d.%d.%s Parrot; http://www.nd.edu/~ccl/)\r\n", CCTOOLS_VERSION_MAJOR, CCTOOLS_VERSION_MINOR, CCTOOLS_VERSION_MICRO); buffer_putliteral(&B, "\r\n"); /* header terminator */ debug(D_HTTP, "%s", buffer_tostring(&B, NULL)); link_putstring(link, buffer_tostring(&B, NULL), stoptime); buffer_free(&B); } if(link_readline(link, line, HTTP_LINE_MAX, stoptime)) { string_chomp(line); debug(D_HTTP, "%s", line); if(sscanf(line, "HTTP/%*d.%*d %d", &response) == 1) { newurl[0] = 0; while(link_readline(link, line, HTTP_LINE_MAX, stoptime)) { string_chomp(line); debug(D_HTTP, "%s", line); sscanf(line, "Location: %s", newurl); sscanf(line, "Content-Length: %" SCNd64, size); if(strlen(line) <= 2) { break; } } switch (response) { case 200: return link; break; case 301: case 302: case 303: case 307: link_close(link); if(newurl[0]) { if(!strcmp(url, newurl)) { debug(D_HTTP, "error: server gave %d redirect from %s back to the same url!", response, url); errno = EIO; return 0; } else { return http_query_size_via_proxy(proxy,newurl,action,size,stoptime,cache_reload); } } else { errno = ENOENT; return 0; } break; default: link_close(link); errno = http_response_to_errno(response); return 0; break; } } else { debug(D_HTTP, "malformed response"); save_errno = ECONNRESET; } } else { debug(D_HTTP, "malformed response"); save_errno = ECONNRESET; } link_close(link); errno = save_errno; return 0; }
int main(int argc, char *argv[]) { char *host = CATALOG_HOST; int port = CATALOG_PORT; static struct option long_options[] = {{"catalog", required_argument, 0, 'c'}, {0,0,0,0}}; signed int c; while ((c = getopt_long(argc, argv, "c:", long_options, NULL)) > -1) { switch (c) { case 'c': host = optarg; break; default: show_help(argv[0]); return EXIT_FAILURE; } } struct datagram *d; d = datagram_create(DATAGRAM_PORT_ANY); if (!d) { fatal("could not create datagram port!"); } buffer_t B; const char *text; size_t text_size; buffer_init(&B); buffer_abortonfailure(&B, 1); struct utsname name; int cpus; int uptime; double load[3]; UINT64_T memory_total, memory_avail; char owner[USERNAME_MAX]; uname(&name); string_tolower(name.sysname); string_tolower(name.machine); string_tolower(name.release); load_average_get(load); cpus = load_average_get_cpus(); memory_info_get(&memory_avail, &memory_total); uptime = uptime_get(); username_get(owner); buffer_printf(&B, "type %s\nversion %d.%d.%s\ncpu %s\nopsys %s\nopsysversion %s\nload1 %0.02lf\nload5 %0.02lf\nload15 %0.02lf\nmemory_total %llu\nmemory_avail %llu\ncpus %d\nuptime %d\nowner %s\n", DEFAULT_TYPE, CCTOOLS_VERSION_MAJOR, CCTOOLS_VERSION_MINOR, CCTOOLS_VERSION_MICRO, name.machine, name.sysname, name.release, load[0], load[1], load[2], (unsigned long long) memory_total, (unsigned long long) memory_avail, cpus, uptime, owner ); int i; for (i = optind; i < argc; i++) { char *name; char *value; name = argv[i]; value = strchr(name, '='); if (!value) { fatal("invalid name/value pair = %s", name); } else { *value++ = 0; } buffer_printf(&B, "%s %s\n", name, value); } text = buffer_tostring(&B, &text_size); char address[DATAGRAM_ADDRESS_MAX]; if (domain_name_cache_lookup(host, address)) { datagram_send(d, text, text_size, address, port); } else { fatal("unable to lookup address of host: %s", host); } buffer_free(&B); datagram_delete(d); return EXIT_SUCCESS; }