/**
* vsscanf - Unformat a buffer into a list of arguments
* @buf: input buffer
* @fmt: format of buffer
* @args: arguments
*/
int vsscanf(const char *buf, const char *fmt, va_list args)
{
const char *str = buf;
char *next;
char digit;
int num = 0;
u8 qualifier;
unsigned int base;
union {
long long s;
unsigned long long u;
} val;
s16 field_width;
bool is_sign;
while (*fmt) {
/* skip any white space in format */
/* white space in format matchs any amount of
* white space, including none, in the input.
*/
if (isspace(*fmt)) {
fmt = skip_spaces(++fmt);
str = skip_spaces(str);
}
/* anything that is not a conversion must match exactly */
if (*fmt != '%' && *fmt) {
if (*fmt++ != *str++)
break;
continue;
}
if (!*fmt)
break;
++fmt;
/* skip this conversion.
* advance both strings to next white space
*/
if (*fmt == '*') {
if (!*str)
break;
while (!isspace(*fmt) && *fmt != '%' && *fmt)
fmt++;
while (!isspace(*str) && *str)
str++;
continue;
}
/* get field width */
field_width = -1;
if (isdigit(*fmt)) {
field_width = skip_atoi(&fmt);
if (field_width <= 0)
break;
}
/* get conversion qualifier */
qualifier = -1;
if (*fmt == 'h' || _tolower(*fmt) == 'l' ||
_tolower(*fmt) == 'z') {
qualifier = *fmt++;
if (unlikely(qualifier == *fmt)) {
if (qualifier == 'h') {
qualifier = 'H';
fmt++;
} else if (qualifier == 'l') {
qualifier = 'L';
fmt++;
}
}
}
if (!*fmt)
break;
if (*fmt == 'n') {
/* return number of characters read so far */
*va_arg(args, int *) = str - buf;
++fmt;
continue;
}
if (!*str)
break;
base = 10;
is_sign = false;
switch (*fmt++) {
case 'c':
{
char *s = (char *)va_arg(args, char*);
if (field_width == -1)
field_width = 1;
do {
*s++ = *str++;
} while (--field_width > 0 && *str);
num++;
}
continue;
case 's':
{
char *s = (char *)va_arg(args, char *);
if (field_width == -1)
field_width = SHRT_MAX;
/* first, skip leading white space in buffer */
str = skip_spaces(str);
/* now copy until next white space */
while (*str && !isspace(*str) && field_width--)
*s++ = *str++;
*s = '\0';
num++;
}
continue;
case 'o':
base = 8;
break;
case 'x':
case 'X':
base = 16;
break;
case 'i':
base = 0;
case 'd':
is_sign = true;
case 'u':
break;
case '%':
/* looking for '%' in str */
if (*str++ != '%')
return num;
continue;
default:
/* invalid format; stop here */
return num;
}
/* have some sort of integer conversion.
* first, skip white space in buffer.
*/
str = skip_spaces(str);
digit = *str;
if (is_sign && digit == '-')
digit = *(str + 1);
if (!digit
|| (base == 16 && !isxdigit(digit))
|| (base == 10 && !isdigit(digit))
|| (base == 8 && (!isdigit(digit) || digit > '7'))
|| (base == 0 && !isdigit(digit)))
break;
if (is_sign)
val.s = qualifier != 'L' ?
strtol(str, &next, base) :
strtoll(str, &next, base);
else
val.u = qualifier != 'L' ?
strtoul(str, &next, base) :
strtoull(str, &next, base);
if (field_width > 0 && next - str > field_width) {
if (base == 0)
_parse_integer_fixup_radix(str, &base);
while (next - str > field_width) {
if (is_sign)
val.s = sdiv64(val.s, base);
else
val.u = udiv64(val.u, base);
--next;
}
}
switch (qualifier) {
case 'H': /* that's 'hh' in format */
if (is_sign)
*va_arg(args, signed char *) = val.s;
else
*va_arg(args, unsigned char *) = val.u;
break;
case 'h':
if (is_sign)
*va_arg(args, short *) = val.s;
else
*va_arg(args, unsigned short *) = val.u;
break;
case 'l':
if (is_sign)
*va_arg(args, long *) = val.s;
else
*va_arg(args, unsigned long *) = val.u;
break;
case 'L':
if (is_sign)
*va_arg(args, long long *) = val.s;
else
*va_arg(args, unsigned long long *) = val.u;
break;
case 'Z':
case 'z':
*va_arg(args, size_t *) = val.u;
break;
default:
if (is_sign)
*va_arg(args, int *) = val.s;
else
*va_arg(args, unsigned int *) = val.u;
break;
}
num++;
if (!next)
break;
str = next;
}
return num;
}
void processline(char *line) {
int rc;
int async = ((line[0] == 'a') && !(startsWith(line, "addauth ")));
if (async) {
line++;
}
if (startsWith(line, "help")) {
fprintf(stderr, " create [+[e|s]] <path>\n");
fprintf(stderr, " create2 [+[e|s]] <path>\n");
fprintf(stderr, " delete <path>\n");
fprintf(stderr, " set <path> <data>\n");
fprintf(stderr, " get <path>\n");
fprintf(stderr, " ls <path>\n");
fprintf(stderr, " ls2 <path>\n");
fprintf(stderr, " sync <path>\n");
fprintf(stderr, " exists <path>\n");
fprintf(stderr, " wexists <path>\n");
fprintf(stderr, " myid\n");
fprintf(stderr, " verbose\n");
fprintf(stderr, " addauth <id> <scheme>\n");
fprintf(stderr, " config\n");
fprintf(stderr, " reconfig [-file <path> | -members <serverId=host:port1:port2;port3>,... | "
" -add <serverId=host:port1:port2;port3>,... | -remove <serverId>,...] [-version <version>]\n");
fprintf(stderr, " quit\n");
fprintf(stderr, "\n");
fprintf(stderr, " prefix the command with the character 'a' to run the command asynchronously.\n");
fprintf(stderr, " run the 'verbose' command to toggle verbose logging.\n");
fprintf(stderr, " i.e. 'aget /foo' to get /foo asynchronously\n");
} else if (startsWith(line, "verbose")) {
if (verbose) {
verbose = 0;
zoo_set_debug_level(ZOO_LOG_LEVEL_WARN);
fprintf(stderr, "logging level set to WARN\n");
} else {
verbose = 1;
zoo_set_debug_level(ZOO_LOG_LEVEL_DEBUG);
fprintf(stderr, "logging level set to DEBUG\n");
}
} else if (startsWith(line, "get ")) {
line += 4;
if (line[0] != '/') {
fprintf(stderr, "Path must start with /, found: %s\n", line);
return;
}
rc = zoo_aget(zh, line, 1, my_data_completion, strdup(line));
if (rc) {
fprintf(stderr, "Error %d for %s\n", rc, line);
}
} else if (strcmp(line, "config") == 0) {
gettimeofday(&startTime, 0);
rc = zoo_agetconfig(zh, 1, my_data_completion, strdup(ZOO_CONFIG_NODE));
if (rc) {
fprintf(stderr, "Error %d for %s\n", rc, line);
}
} else if (startsWith(line, "reconfig ")) {
int syntaxError = 0;
char* p = NULL;
char* joining = NULL;
char* leaving = NULL;
char* members = NULL;
size_t members_size = 0;
int mode = 0; // 0 = not set, 1 = incremental, 2 = non-incremental
int64_t version = -1;
line += 9;
p = strtok (strdup(line)," ");
while (p != NULL) {
if (strcmp(p, "-add")==0) {
p = strtok (NULL," ");
if (mode == 2 || p == NULL) {
syntaxError = 1;
break;
}
mode = 1;
joining = strdup(p);
} else if (strcmp(p, "-remove")==0){
p = strtok (NULL," ");
if (mode == 2 || p == NULL) {
syntaxError = 1;
break;
}
mode = 1;
leaving = strdup(p);
} else if (strcmp(p, "-members")==0) {
p = strtok (NULL," ");
if (mode == 1 || p == NULL) {
syntaxError = 1;
break;
}
mode = 2;
members = strdup(p);
} else if (strcmp(p, "-file")==0){
FILE *fp = NULL;
p = strtok (NULL," ");
if (mode == 1 || p == NULL) {
syntaxError = 1;
break;
}
mode = 2;
fp = fopen(p, "r");
if (fp == NULL) {
fprintf(stderr, "Error reading file: %s\n", p);
syntaxError = 1;
break;
}
fseek(fp, 0L, SEEK_END); /* Position to end of file */
members_size = ftell(fp); /* Get file length */
rewind(fp); /* Back to start of file */
members = calloc(members_size + 1, sizeof(char));
if(members == NULL )
{
fprintf(stderr, "\nInsufficient memory to read file: %s\n", p);
syntaxError = 1;
fclose(fp);
break;
}
/* Read the entire file into members
* NOTE: -- fread returns number of items successfully read
* not the number of bytes. We're requesting one item of
* members_size bytes. So we expect the return value here
* to be 1.
*/
if (fread(members, members_size, 1, fp) != 1){
fprintf(stderr, "Error reading file: %s\n", p);
syntaxError = 1;
fclose(fp);
break;
}
fclose(fp);
} else if (strcmp(p, "-version")==0){
p = strtok (NULL," ");
if (version != -1 || p == NULL){
syntaxError = 1;
break;
}
#ifdef WIN32
version = _strtoui64(p, NULL, 16);
#else
version = strtoull(p, NULL, 16);
#endif
if (version < 0) {
syntaxError = 1;
break;
}
} else {
syntaxError = 1;
break;
}
p = strtok (NULL," ");
}
if (syntaxError) return;
rc = zoo_areconfig(zh, joining, leaving, members, version, my_data_completion, strdup(line));
free(joining);
free(leaving);
free(members);
if (rc) {
fprintf(stderr, "Error %d for %s\n", rc, line);
}
} else if (startsWith(line, "set ")) {
char *ptr;
line += 4;
if (line[0] != '/') {
fprintf(stderr, "Path must start with /, found: %s\n", line);
return;
}
ptr = strchr(line, ' ');
if (!ptr) {
fprintf(stderr, "No data found after path\n");
return;
}
*ptr = '\0';
ptr++;
if (async) {
rc = zoo_aset(zh, line, ptr, strlen(ptr), -1, my_stat_completion,
strdup(line));
} else {
struct Stat stat;
rc = zoo_set2(zh, line, ptr, strlen(ptr), -1, &stat);
}
if (rc) {
fprintf(stderr, "Error %d for %s\n", rc, line);
}
} else if (startsWith(line, "ls ")) {
line += 3;
if (line[0] != '/') {
fprintf(stderr, "Path must start with /, found: %s\n", line);
return;
}
gettimeofday(&startTime, 0);
rc= zoo_aget_children(zh, line, 1, my_strings_completion, strdup(line));
if (rc) {
fprintf(stderr, "Error %d for %s\n", rc, line);
}
} else if (startsWith(line, "ls2 ")) {
line += 4;
if (line[0] != '/') {
fprintf(stderr, "Path must start with /, found: %s\n", line);
return;
}
gettimeofday(&startTime, 0);
rc= zoo_aget_children2(zh, line, 1, my_strings_stat_completion, strdup(line));
if (rc) {
fprintf(stderr, "Error %d for %s\n", rc, line);
}
} else if (startsWith(line, "create ") || startsWith(line, "create2 ")) {
int flags = 0;
int is_create2 = startsWith(line, "create2 ");
line += is_create2 ? 8 : 7;
if (line[0] == '+') {
line++;
if (line[0] == 'e') {
flags |= ZOO_EPHEMERAL;
line++;
}
if (line[0] == 's') {
flags |= ZOO_SEQUENCE;
line++;
}
line++;
}
if (line[0] != '/') {
fprintf(stderr, "Path must start with /, found: %s\n", line);
return;
}
fprintf(stderr, "Creating [%s] node\n", line);
// {
// struct ACL _CREATE_ONLY_ACL_ACL[] = {{ZOO_PERM_CREATE, ZOO_ANYONE_ID_UNSAFE}};
// struct ACL_vector CREATE_ONLY_ACL = {1,_CREATE_ONLY_ACL_ACL};
// rc = zoo_acreate(zh, line, "new", 3, &CREATE_ONLY_ACL, flags,
// my_string_completion, strdup(line));
// }
if (is_create2) {
rc = zoo_acreate2(zh, line, "new", 3, &ZOO_OPEN_ACL_UNSAFE, flags,
my_string_stat_completion_free_data, strdup(line));
} else {
rc = zoo_acreate(zh, line, "new", 3, &ZOO_OPEN_ACL_UNSAFE, flags,
my_string_completion_free_data, strdup(line));
}
if (rc) {
fprintf(stderr, "Error %d for %s\n", rc, line);
}
} else if (startsWith(line, "delete ")) {
line += 7;
if (line[0] != '/') {
fprintf(stderr, "Path must start with /, found: %s\n", line);
return;
}
if (async) {
rc = zoo_adelete(zh, line, -1, my_void_completion, strdup(line));
} else {
rc = zoo_delete(zh, line, -1);
}
if (rc) {
fprintf(stderr, "Error %d for %s\n", rc, line);
}
} else if (startsWith(line, "sync ")) {
line += 5;
if (line[0] != '/') {
fprintf(stderr, "Path must start with /, found: %s\n", line);
return;
}
rc = zoo_async(zh, line, my_string_completion_free_data, strdup(line));
if (rc) {
fprintf(stderr, "Error %d for %s\n", rc, line);
}
} else if (startsWith(line, "wexists ")) {
#ifdef THREADED
struct Stat stat;
#endif
line += 8;
if (line[0] != '/') {
fprintf(stderr, "Path must start with /, found: %s\n", line);
return;
}
#ifndef THREADED
rc = zoo_awexists(zh, line, watcher, (void*) 0, my_stat_completion, strdup(line));
#else
rc = zoo_wexists(zh, line, watcher, (void*) 0, &stat);
#endif
if (rc) {
fprintf(stderr, "Error %d for %s\n", rc, line);
}
} else if (startsWith(line, "exists ")) {
#ifdef THREADED
struct Stat stat;
#endif
line += 7;
if (line[0] != '/') {
fprintf(stderr, "Path must start with /, found: %s\n", line);
return;
}
#ifndef THREADED
rc = zoo_aexists(zh, line, 1, my_stat_completion, strdup(line));
#else
rc = zoo_exists(zh, line, 1, &stat);
#endif
if (rc) {
fprintf(stderr, "Error %d for %s\n", rc, line);
}
} else if (strcmp(line, "myid") == 0) {
printf("session Id = %llx\n", _LL_CAST_ zoo_client_id(zh)->client_id);
} else if (strcmp(line, "reinit") == 0) {
zookeeper_close(zh);
// we can't send myid to the server here -- zookeeper_close() removes
// the session on the server. We must start anew.
zh = zookeeper_init(hostPort, watcher, 30000, 0, 0, 0);
} else if (startsWith(line, "quit")) {
fprintf(stderr, "Quitting...\n");
shutdownThisThing=1;
} else if (startsWith(line, "od")) {
const char val[]="fire off";
fprintf(stderr, "Overdosing...\n");
rc = zoo_aset(zh, "/od", val, sizeof(val)-1, -1, od_completion, 0);
if (rc)
fprintf(stderr, "od command failed: %d\n", rc);
} else if (startsWith(line, "addauth ")) {
char *ptr;
line += 8;
ptr = strchr(line, ' ');
if (ptr) {
*ptr = '\0';
ptr++;
}
zoo_add_auth(zh, line, ptr, ptr ? strlen(ptr) : 0, NULL, NULL);
}
}
static void xml_to_node(xmlNodePtr xml_node, plist_t * plist_node)
{
xmlNodePtr node = NULL;
plist_data_t data = NULL;
plist_t subnode = NULL;
//for string
long len = 0;
int type = 0;
if (!xml_node)
return;
for (node = xml_node->children; node; node = node->next)
{
while (node && !xmlStrcmp(node->name, XPLIST_TEXT))
node = node->next;
if (!node)
break;
if (!xmlStrcmp(node->name, BAD_CAST("comment"))) {
continue;
}
data = plist_new_plist_data();
subnode = plist_new_node(data);
if (*plist_node)
node_attach(*plist_node, subnode);
else
*plist_node = subnode;
if (!xmlStrcmp(node->name, XPLIST_TRUE))
{
data->boolval = TRUE;
data->type = PLIST_BOOLEAN;
data->length = 1;
continue;
}
if (!xmlStrcmp(node->name, XPLIST_FALSE))
{
data->boolval = FALSE;
data->type = PLIST_BOOLEAN;
data->length = 1;
continue;
}
if (!xmlStrcmp(node->name, XPLIST_INT))
{
xmlChar *strval = xmlNodeGetContent(node);
data->intval = strtoull((char*)strval, NULL, 0);
data->type = PLIST_UINT;
data->length = 8;
xmlFree(strval);
continue;
}
if (!xmlStrcmp(node->name, XPLIST_REAL))
{
xmlChar *strval = xmlNodeGetContent(node);
data->realval = atof((char *) strval);
data->type = PLIST_REAL;
data->length = 8;
xmlFree(strval);
continue;
}
if (!xmlStrcmp(node->name, XPLIST_DATE))
{
xmlChar *strval = xmlNodeGetContent(node);
time_t time = 0;
if (strlen((const char*)strval) >= 11) {
struct tm btime;
struct tm* tm_utc;
parse_date((const char*)strval, &btime);
time = mktime(&btime);
tm_utc = gmtime(&time);
time -= (mktime(tm_utc) - time);
}
data->timeval.tv_sec = (long)time;
data->timeval.tv_usec = 0;
data->type = PLIST_DATE;
data->length = sizeof(struct timeval);
xmlFree(strval);
continue;
}
if (!xmlStrcmp(node->name, XPLIST_STRING))
{
xmlChar *strval = xmlNodeGetContent(node);
len = strlen((char *) strval);
type = xmlDetectCharEncoding(strval, len);
if (XML_CHAR_ENCODING_UTF8 == type || XML_CHAR_ENCODING_ASCII == type || XML_CHAR_ENCODING_NONE == type)
{
data->strval = strdup((char *) strval);
data->type = PLIST_STRING;
data->length = strlen(data->strval);
}
xmlFree(strval);
continue;
}
if (!xmlStrcmp(node->name, XPLIST_KEY))
{
xmlChar *strval = xmlNodeGetContent(node);
data->strval = strdup((char *) strval);
data->type = PLIST_KEY;
data->length = strlen(data->strval);
xmlFree(strval);
continue;
}
if (!xmlStrcmp(node->name, XPLIST_DATA))
{
xmlChar *strval = xmlNodeGetContent(node);
size_t size = 0;
unsigned char *dec = base64decode((char*)strval, &size);
data->buff = (uint8_t *) malloc(size * sizeof(uint8_t));
memcpy(data->buff, dec, size * sizeof(uint8_t));
free(dec);
data->length = size;
data->type = PLIST_DATA;
xmlFree(strval);
continue;
}
if (!xmlStrcmp(node->name, XPLIST_ARRAY))
{
data->type = PLIST_ARRAY;
xml_to_node(node, &subnode);
continue;
}
if (!xmlStrcmp(node->name, XPLIST_DICT))
{
data->type = PLIST_DICT;
xml_to_node(node, &subnode);
if (plist_get_node_type(subnode) == PLIST_DICT) {
if (plist_dict_get_size(subnode) == 1) {
plist_t uid = plist_dict_get_item(subnode, "CF$UID");
if (uid) {
uint64_t val = 0;
plist_get_uint_val(uid, &val);
plist_dict_remove_item(subnode, "CF$UID");
plist_data_t nodedata = plist_get_data((node_t*)subnode);
free(nodedata->buff);
nodedata->type = PLIST_UID;
nodedata->length = sizeof(uint64_t);
nodedata->intval = val;
}
}
}
continue;
}
}
}
static int
diskarenapart(HConnect *c, char *disk, Part *p)
{
char *arenaname;
ArenaPart ap;
ArenaHead head;
Arena arena;
char *table;
char *score;
char *clump;
uchar *blk;
vlong start, end, off;
char tbuf[60];
hprint(&c->hout, "<h1>arena partition %s</h1>\n", disk);
if((table = readap(p, &ap)) == nil){
hprint(&c->hout, "%r\n");
goto out;
}
hprint(&c->hout, "<pre>\n");
hprint(&c->hout, "version=%d blocksize=%d base=%d\n",
ap.version, ap.blocksize, ap.arenabase);
hprint(&c->hout, "</pre>\n");
arenaname = hargstr(c, "arena", "");
if(arenaname[0] == 0){
diskarenatable(c, disk, table);
goto out;
}
if(xfindarena(table, arenaname, &start, &end) < 0){
hprint(&c->hout, "no such arena %s\n", arenaname);
goto out;
}
hprint(&c->hout, "<h2>arena %s</h2>\n", arenaname);
hprint(&c->hout, "<pre>start=%#llx end=%#llx<pre>\n", start, end);
if(end < start || end - start < HeadSize){
hprint(&c->hout, "bad size %#llx\n", end - start);
goto out;
}
// read arena header, tail
blk = vtmalloc(HeadSize);
if(readpart(p, start, blk, HeadSize) != HeadSize){
hprint(&c->hout, "reading header: %r\n");
vtfree(blk);
goto out;
}
if(unpackarenahead(&head, blk) < 0){
hprint(&c->hout, "corrupt arena header: %r\n");
// hhex(blk, HeadSize);
vtfree(blk);
goto out;
}
vtfree(blk);
hprint(&c->hout, "head:\n<pre>\n");
hprint(&c->hout, "version=%d name=%s blocksize=%d size=%#llx clumpmagic=%#ux\n",
head.version, head.name, head.blocksize, head.size,
head.clumpmagic);
hprint(&c->hout, "</pre><br><br>\n");
if(head.blocksize > MaxIoSize || head.blocksize >= end - start){
hprint(&c->hout, "corrupt block size %d\n", head.blocksize);
goto out;
}
blk = vtmalloc(head.blocksize);
if(readpart(p, end - head.blocksize, blk, head.blocksize) < 0){
hprint(&c->hout, "reading tail: %r\n");
vtfree(blk);
goto out;
}
memset(&arena, 0, sizeof arena);
arena.part = p;
arena.blocksize = head.blocksize;
arena.clumpmax = head.blocksize / ClumpInfoSize;
arena.base = start + head.blocksize;
arena.size = end - start - 2 * head.blocksize;
if(unpackarena(&arena, blk) < 0){
vtfree(blk);
goto out;
}
scorecp(arena.score, blk+head.blocksize - VtScoreSize);
vtfree(blk);
hprint(&c->hout, "tail:\n<pre>\n");
hprint(&c->hout, "version=%d name=%s\n", arena.version, arena.name);
hprint(&c->hout, "ctime=%d %s\n", arena.ctime, fmttime(tbuf, arena.ctime));
hprint(&c->hout, "wtime=%d %s\n", arena.wtime, fmttime(tbuf, arena.wtime));
hprint(&c->hout, "clumpmagic=%#ux\n", arena.clumpmagic);
hprint(&c->hout, "score %V\n", arena.score);
hprint(&c->hout, "diskstats:\n");
hprint(&c->hout, "\tclumps=%,d cclumps=%,d used=%,lld uncsize=%,lld sealed=%d\n",
arena.diskstats.clumps, arena.diskstats.cclumps,
arena.diskstats.used, arena.diskstats.uncsize,
arena.diskstats.sealed);
hprint(&c->hout, "memstats:\n");
hprint(&c->hout, "\tclumps=%,d cclumps=%,d used=%,lld uncsize=%,lld sealed=%d\n",
arena.memstats.clumps, arena.memstats.cclumps,
arena.memstats.used, arena.memstats.uncsize,
arena.memstats.sealed);
if(arena.clumpmax == 0){
hprint(&c->hout, "bad clumpmax\n");
goto out;
}
score = hargstr(c, "score", "");
clump = hargstr(c, "clump", "");
if(clump[0]){
off = strtoull(clump, 0, 0);
diskarenaclump(c, &arena, off, score[0] ? score : nil);
}else if(score[0]){
diskarenaclump(c, &arena, -1, score);
}else{
diskarenatoc(c, &arena);
}
out:
free(table);
return 0;
}
/*
* Generate a mirroring data stream from the specific source over the
* entire key range, but restricted to the specified transaction range.
*
* The HAMMER VFS does most of the work, we add a few new mrecord
* types to negotiate the TID ranges and verify that the entire
* stream made it to the destination.
*
* streaming will be 0 for mirror-read, 1 for mirror-stream. The code will
* set up a fake value of -1 when running the histogram for mirror-read.
*/
void
hammer_cmd_mirror_read(char **av, int ac, int streaming)
{
struct hammer_ioc_mirror_rw mirror;
struct hammer_ioc_pseudofs_rw pfs;
union hammer_ioc_mrecord_any mrec_tmp;
struct hammer_ioc_mrecord_head pickup;
hammer_ioc_mrecord_any_t mrec;
hammer_tid_t sync_tid;
histogram_t histogram_ary;
const char *filesystem;
char *buf = malloc(SERIALBUF_SIZE);
int interrupted = 0;
int error;
int fd;
int n;
int didwork;
int histogram;
int histindex;
int histmax;
int repeat = 0;
int sameline;
int64_t total_bytes;
time_t base_t = time(NULL);
struct timeval bwtv;
uint64_t bwcount;
uint64_t estbytes;
if (ac == 0 || ac > 2)
mirror_usage(1);
filesystem = av[0];
hammer_check_restrict(filesystem);
pickup.signature = 0;
pickup.type = 0;
histogram = 0;
histindex = 0;
histmax = 0;
histogram_ary = NULL;
sameline = 0;
again:
bzero(&mirror, sizeof(mirror));
hammer_key_beg_init(&mirror.key_beg);
hammer_key_end_init(&mirror.key_end);
fd = getpfs(&pfs, filesystem);
if (streaming >= 0)
score_printf(LINE1, "Running");
if (streaming >= 0 && VerboseOpt && VerboseOpt < 2) {
fprintf(stderr, "%cRunning \b\b", (sameline ? '\r' : '\n'));
fflush(stderr);
sameline = 1;
}
sameline = 1;
total_bytes = 0;
gettimeofday(&bwtv, NULL);
bwcount = 0;
/*
* Send initial header for the purpose of determining the
* shared-uuid.
*/
generate_mrec_header(fd, pfs.pfs_id, &mrec_tmp);
write_mrecord(1, HAMMER_MREC_TYPE_PFSD,
&mrec_tmp, sizeof(mrec_tmp.pfs));
/*
* In 2-way mode the target will send us a PFS info packet
* first. Use the target's current snapshot TID as our default
* begin TID.
*/
if (TwoWayPipeOpt) {
mirror.tid_beg = 0;
n = validate_mrec_header(fd, 0, 0, pfs.pfs_id, &pickup,
NULL, &mirror.tid_beg);
if (n < 0) { /* got TERM record */
relpfs(fd, &pfs);
free(buf);
free(histogram_ary);
return;
}
++mirror.tid_beg;
} else if (streaming && histogram) {
mirror.tid_beg = histogram_ary[histindex].tid + 1;
} else {
mirror.tid_beg = 0;
}
/*
* Write out the PFS header, tid_beg will be updated if our PFS
* has a larger begin sync. tid_end is set to the latest source
* TID whos flush cycle has completed.
*/
generate_mrec_header(fd, pfs.pfs_id, &mrec_tmp);
if (mirror.tid_beg < mrec_tmp.pfs.pfsd.sync_beg_tid)
mirror.tid_beg = mrec_tmp.pfs.pfsd.sync_beg_tid;
mirror.tid_end = mrec_tmp.pfs.pfsd.sync_end_tid;
mirror.ubuf = buf;
mirror.size = SERIALBUF_SIZE;
mirror.pfs_id = pfs.pfs_id;
mirror.shared_uuid = pfs.ondisk->shared_uuid;
/*
* XXX If the histogram is exhausted and the TID delta is large
* the stream might have been offline for a while and is
* now picking it up again. Do another histogram.
*/
#if 0
if (streaming && histogram && histindex == histend) {
if (mirror.tid_end - mirror.tid_beg > BULK_MINIMUM)
histogram = 0;
}
#endif
/*
* Initial bulk startup control, try to do some incremental
* mirroring in order to allow the stream to be killed and
* restarted without having to start over.
*/
if (histogram == 0 && BulkOpt == 0) {
if (VerboseOpt && repeat == 0) {
fprintf(stderr, "\n");
sameline = 0;
}
histmax = generate_histogram(fd, filesystem,
&histogram_ary, &mirror,
&repeat);
histindex = 0;
histogram = 1;
/*
* Just stream the histogram, then stop
*/
if (streaming == 0)
streaming = -1;
}
if (streaming && histogram) {
++histindex;
mirror.tid_end = histogram_ary[histindex].tid;
estbytes = histogram_ary[histindex-1].bytes;
mrec_tmp.pfs.pfsd.sync_end_tid = mirror.tid_end;
} else {
estbytes = 0;
}
write_mrecord(1, HAMMER_MREC_TYPE_PFSD,
&mrec_tmp, sizeof(mrec_tmp.pfs));
/*
* A cycle file overrides the beginning TID only if we are
* not operating in two-way or histogram mode.
*/
if (TwoWayPipeOpt == 0 && histogram == 0) {
hammer_get_cycle(&mirror.key_beg, &mirror.tid_beg);
}
/*
* An additional argument overrides the beginning TID regardless
* of what mode we are in. This is not recommending if operating
* in two-way mode.
*/
if (ac == 2)
mirror.tid_beg = strtoull(av[1], NULL, 0);
if (streaming == 0 || VerboseOpt >= 2) {
fprintf(stderr,
"Mirror-read: Mirror %016jx to %016jx",
(uintmax_t)mirror.tid_beg, (uintmax_t)mirror.tid_end);
if (histogram)
fprintf(stderr, " (bulk= %ju)", (uintmax_t)estbytes);
fprintf(stderr, "\n");
fflush(stderr);
}
if (mirror.key_beg.obj_id != (int64_t)HAMMER_MIN_OBJID) {
fprintf(stderr, "Mirror-read: Resuming at object %016jx\n",
(uintmax_t)mirror.key_beg.obj_id);
}
/*
* Nothing to do if begin equals end.
*/
if (mirror.tid_beg >= mirror.tid_end) {
if (streaming == 0 || VerboseOpt >= 2)
fprintf(stderr, "Mirror-read: No work to do\n");
sleep(DelayOpt);
didwork = 0;
histogram = 0;
goto done;
}
didwork = 1;
/*
* Write out bulk records
*/
mirror.ubuf = buf;
mirror.size = SERIALBUF_SIZE;
do {
mirror.count = 0;
mirror.pfs_id = pfs.pfs_id;
mirror.shared_uuid = pfs.ondisk->shared_uuid;
if (ioctl(fd, HAMMERIOC_MIRROR_READ, &mirror) < 0) {
score_printf(LINE3, "Mirror-read %s failed: %s",
filesystem, strerror(errno));
fprintf(stderr, "Mirror-read %s failed: %s\n",
filesystem, strerror(errno));
exit(1);
}
if (mirror.head.flags & HAMMER_IOC_HEAD_ERROR) {
score_printf(LINE3, "Mirror-read %s fatal error %d",
filesystem, mirror.head.error);
fprintf(stderr,
"Mirror-read %s fatal error %d\n",
filesystem, mirror.head.error);
exit(1);
}
if (mirror.count) {
if (BandwidthOpt) {
n = writebw(1, mirror.ubuf, mirror.count,
&bwcount, &bwtv);
} else {
n = write(1, mirror.ubuf, mirror.count);
}
if (n != mirror.count) {
score_printf(LINE3,
"Mirror-read %s failed: "
"short write",
filesystem);
fprintf(stderr,
"Mirror-read %s failed: "
"short write\n",
filesystem);
exit(1);
}
}
total_bytes += mirror.count;
if (streaming && VerboseOpt) {
fprintf(stderr,
"\rscan obj=%016jx tids=%016jx:%016jx %11jd",
(uintmax_t)mirror.key_cur.obj_id,
(uintmax_t)mirror.tid_beg,
(uintmax_t)mirror.tid_end,
(intmax_t)total_bytes);
fflush(stderr);
sameline = 0;
} else if (streaming) {
score_printf(LINE2,
"obj=%016jx tids=%016jx:%016jx %11jd",
(uintmax_t)mirror.key_cur.obj_id,
(uintmax_t)mirror.tid_beg,
(uintmax_t)mirror.tid_end,
(intmax_t)total_bytes);
}
mirror.key_beg = mirror.key_cur;
/*
* Deal with time limit option
*/
if (TimeoutOpt &&
(unsigned)(time(NULL) - base_t) > (unsigned)TimeoutOpt) {
score_printf(LINE3,
"Mirror-read %s interrupted by timer at"
" %016jx",
filesystem,
(uintmax_t)mirror.key_cur.obj_id);
fprintf(stderr,
"Mirror-read %s interrupted by timer at"
" %016jx\n",
filesystem,
(uintmax_t)mirror.key_cur.obj_id);
interrupted = 1;
break;
}
} while (mirror.count != 0);
done:
if (streaming && VerboseOpt && sameline == 0) {
fprintf(stderr, "\n");
fflush(stderr);
sameline = 1;
}
/*
* Write out the termination sync record - only if not interrupted
*/
if (interrupted == 0) {
if (didwork) {
write_mrecord(1, HAMMER_MREC_TYPE_SYNC,
&mrec_tmp, sizeof(mrec_tmp.sync));
} else {
write_mrecord(1, HAMMER_MREC_TYPE_IDLE,
&mrec_tmp, sizeof(mrec_tmp.sync));
}
}
/*
* If the -2 option was given (automatic when doing mirror-copy),
* a two-way pipe is assumed and we expect a response mrec from
* the target.
*/
if (TwoWayPipeOpt) {
mrec = read_mrecord(0, &error, &pickup);
if (mrec == NULL ||
mrec->head.type != HAMMER_MREC_TYPE_UPDATE ||
mrec->head.rec_size != sizeof(mrec->update)) {
fprintf(stderr, "mirror_read: Did not get final "
"acknowledgement packet from target\n");
exit(1);
}
if (interrupted) {
if (CyclePath) {
hammer_set_cycle(&mirror.key_cur,
mirror.tid_beg);
fprintf(stderr, "Cyclefile %s updated for "
"continuation\n", CyclePath);
}
} else {
sync_tid = mrec->update.tid;
if (CyclePath) {
hammer_key_beg_init(&mirror.key_beg);
hammer_set_cycle(&mirror.key_beg, sync_tid);
fprintf(stderr,
"Cyclefile %s updated to 0x%016jx\n",
CyclePath, (uintmax_t)sync_tid);
}
}
free(mrec);
} else if (CyclePath) {
/* NOTE! mirror.tid_beg cannot be updated */
fprintf(stderr, "Warning: cycle file (-c option) cannot be "
"fully updated unless you use mirror-copy\n");
hammer_set_cycle(&mirror.key_beg, mirror.tid_beg);
}
if (streaming && interrupted == 0) {
time_t t1 = time(NULL);
time_t t2;
/*
* Try to break down large bulk transfers into smaller ones
* so it can sync the transaction id on the slave. This
* way if we get interrupted a restart doesn't have to
* start from scratch.
*/
if (streaming && histogram) {
if (histindex != histmax) {
if (VerboseOpt && VerboseOpt < 2 &&
streaming >= 0) {
fprintf(stderr, " (bulk incremental)");
}
relpfs(fd, &pfs);
goto again;
}
}
if (VerboseOpt && streaming >= 0) {
fprintf(stderr, " W");
fflush(stderr);
} else if (streaming >= 0) {
score_printf(LINE1, "Waiting");
}
pfs.ondisk->sync_end_tid = mirror.tid_end;
if (streaming < 0) {
/*
* Fake streaming mode when using a histogram to
* break up a mirror-read, do not wait on source.
*/
streaming = 0;
} else if (ioctl(fd, HAMMERIOC_WAI_PSEUDOFS, &pfs) < 0) {
score_printf(LINE3,
"Mirror-read %s: cannot stream: %s\n",
filesystem, strerror(errno));
fprintf(stderr,
"Mirror-read %s: cannot stream: %s\n",
filesystem, strerror(errno));
} else {
t2 = time(NULL) - t1;
if (t2 >= 0 && t2 < DelayOpt) {
if (VerboseOpt) {
fprintf(stderr, "\bD");
fflush(stderr);
}
sleep(DelayOpt - t2);
}
if (VerboseOpt) {
fprintf(stderr, "\b ");
fflush(stderr);
}
relpfs(fd, &pfs);
goto again;
}
}
write_mrecord(1, HAMMER_MREC_TYPE_TERM,
&mrec_tmp, sizeof(mrec_tmp.sync));
relpfs(fd, &pfs);
free(buf);
free(histogram_ary);
fprintf(stderr, "Mirror-read %s succeeded\n", filesystem);
}
int main (int argc, char **argv) {
char *brokers = "localhost";
char mode = 'C';
char *topic = NULL;
const char *key = NULL;
int partition = RD_KAFKA_PARTITION_UA; /* random */
int opt;
int msgcnt = -1;
int sendflags = 0;
char *msgpattern = "librdkafka_performance testing!";
int msgsize = strlen(msgpattern);
const char *debug = NULL;
rd_ts_t now;
char errstr[512];
uint64_t seq = 0;
int seed = time(NULL);
rd_kafka_topic_t *rkt;
rd_kafka_conf_t *conf;
rd_kafka_topic_conf_t *topic_conf;
const char *compression = "no";
int64_t start_offset = 0;
int batch_size = 0;
int idle = 0;
/* Kafka configuration */
conf = rd_kafka_conf_new();
rd_kafka_conf_set_error_cb(conf, err_cb);
rd_kafka_conf_set_dr_cb(conf, msg_delivered);
/* Producer config */
rd_kafka_conf_set(conf, "queue.buffering.max.messages", "500000",
NULL, 0);
rd_kafka_conf_set(conf, "message.send.max.retries", "3", NULL, 0);
rd_kafka_conf_set(conf, "retry.backoff.ms", "500", NULL, 0);
/* Consumer config */
/* Tell rdkafka to (try to) maintain 1M messages
* in its internal receive buffers. This is to avoid
* application -> rdkafka -> broker per-message ping-pong
* latency.
* The larger the local queue, the higher the performance.
* Try other values with: ... -X queued.min.messages=1000
*/
rd_kafka_conf_set(conf, "queued.min.messages", "1000000", NULL, 0);
/* Kafka topic configuration */
topic_conf = rd_kafka_topic_conf_new();
rd_kafka_topic_conf_set(topic_conf, "message.timeout.ms", "5000",
NULL, 0);
while ((opt =
getopt(argc, argv,
"PCt:p:b:s:k:c:fi:Dd:m:S:x:R:a:z:o:X:B:eT:qI")) != -1) {
switch (opt) {
case 'P':
case 'C':
mode = opt;
break;
case 't':
topic = optarg;
break;
case 'p':
partition = atoi(optarg);
break;
case 'b':
brokers = optarg;
break;
case 's':
msgsize = atoi(optarg);
break;
case 'k':
key = optarg;
break;
case 'c':
msgcnt = atoi(optarg);
break;
case 'D':
sendflags |= RD_KAFKA_MSG_F_FREE;
break;
case 'i':
dispintvl = atoi(optarg);
break;
case 'm':
msgpattern = optarg;
break;
case 'S':
seq = strtoull(optarg, NULL, 10);
do_seq = 1;
break;
case 'x':
exit_after = atoi(optarg);
break;
case 'R':
seed = atoi(optarg);
break;
case 'a':
if (rd_kafka_topic_conf_set(topic_conf,
"request.required.acks",
optarg,
errstr, sizeof(errstr)) !=
RD_KAFKA_CONF_OK) {
fprintf(stderr, "%% %s\n", errstr);
exit(1);
}
break;
case 'B':
batch_size = atoi(optarg);
break;
case 'z':
if (rd_kafka_conf_set(conf, "compression.codec",
optarg,
errstr, sizeof(errstr)) !=
RD_KAFKA_CONF_OK) {
fprintf(stderr, "%% %s\n", errstr);
exit(1);
}
compression = optarg;
break;
case 'o':
start_offset = strtoll(optarg, NULL, 10);
break;
case 'e':
exit_eof = 1;
break;
case 'd':
debug = optarg;
break;
case 'X':
{
char *name, *val;
rd_kafka_conf_res_t res;
if (!strcmp(optarg, "list") ||
!strcmp(optarg, "help")) {
rd_kafka_conf_properties_show(stdout);
exit(0);
}
name = optarg;
if (!(val = strchr(name, '='))) {
fprintf(stderr, "%% Expected "
"-X property=value, not %s\n", name);
exit(1);
}
*val = '\0';
val++;
res = RD_KAFKA_CONF_UNKNOWN;
/* Try "topic." prefixed properties on topic
* conf first, and then fall through to global if
* it didnt match a topic configuration property. */
if (!strncmp(name, "topic.", strlen("topic.")))
res = rd_kafka_topic_conf_set(topic_conf,
name+
strlen("topic"),
val,
errstr,
sizeof(errstr));
if (res == RD_KAFKA_CONF_UNKNOWN)
res = rd_kafka_conf_set(conf, name, val,
errstr, sizeof(errstr));
if (res != RD_KAFKA_CONF_OK) {
fprintf(stderr, "%% %s\n", errstr);
exit(1);
}
}
break;
case 'T':
if (rd_kafka_conf_set(conf, "statistics.interval.ms",
optarg, errstr, sizeof(errstr)) !=
RD_KAFKA_CONF_OK) {
fprintf(stderr, "%% %s\n", errstr);
exit(1);
}
rd_kafka_conf_set_stats_cb(conf, stats_cb);
break;
case 'q':
quiet = 1;
break;
case 'I':
idle = 1;
break;
default:
goto usage;
}
}
if (!topic || optind != argc) {
usage:
fprintf(stderr,
"Usage: %s [-C|-P] -t <topic> "
"[-p <partition>] [-b <broker,broker..>] [options..]\n"
"\n"
"librdkafka version %s (0x%08x)\n"
"\n"
" Options:\n"
" -C | -P Consumer or Producer mode\n"
" -t <topic> Topic to fetch / produce\n"
" -p <num> Partition (defaults to random)\n"
" -b <brokers> Broker address list (host[:port],..)\n"
" -s <size> Message size (producer)\n"
" -k <key> Message key (producer)\n"
" -c <cnt> Messages to transmit/receive\n"
" -D Copy/Duplicate data buffer (producer)\n"
" -i <ms> Display interval\n"
" -m <msg> Message payload pattern\n"
" -S <start> Send a sequence number starting at "
"<start> as payload\n"
" -R <seed> Random seed value (defaults to time)\n"
" -a <acks> Required acks (producer): "
"-1, 0, 1, >1\n"
" -B <size> Consume batch size (# of msgs)\n"
" -z <codec> Enable compression:\n"
" none|gzip|snappy\n"
" -o <offset> Start offset (consumer)\n"
" -d [facs..] Enable debugging contexts:\n"
" %s\n"
" -X <prop=name> Set arbitrary librdkafka "
"configuration property\n"
" Properties prefixed with \"topic.\" "
"will be set on topic object.\n"
" Use '-X list' to see the full list\n"
" of supported properties.\n"
" -T <intvl> Enable statistics from librdkafka at "
"specified interval (ms)\n"
" -q Be more quiet\n"
" -I Idle: dont produce any messages\n"
"\n"
" In Consumer mode:\n"
" consumes messages and prints thruput\n"
" If -B <..> is supplied the batch consumer\n"
" mode is used, else the callback mode is used.\n"
"\n"
" In Producer mode:\n"
" writes messages of size -s <..> and prints thruput\n"
"\n",
argv[0],
rd_kafka_version_str(), rd_kafka_version(),
RD_KAFKA_DEBUG_CONTEXTS);
exit(1);
}
dispintvl *= 1000; /* us */
printf("%% Using random seed %i\n", seed);
srand(seed);
signal(SIGINT, stop);
signal(SIGUSR1, sig_usr1);
if (debug &&
rd_kafka_conf_set(conf, "debug", debug, errstr, sizeof(errstr)) !=
RD_KAFKA_CONF_OK) {
printf("%% Debug configuration failed: %s: %s\n",
errstr, debug);
exit(1);
}
/* Socket hangups are gracefully handled in librdkafka on socket error
* without the use of signals, so SIGPIPE should be ignored by the
* calling program. */
signal(SIGPIPE, SIG_IGN);
if (msgcnt != -1)
forever = 0;
if (mode == 'P') {
/*
* Producer
*/
char *sbuf;
char *pbuf;
int outq;
int i;
int keylen = key ? strlen(key) : 0;
off_t rof = 0;
size_t plen = strlen(msgpattern);
if (do_seq) {
if (msgsize < strlen("18446744073709551615: ")+1)
msgsize = strlen("18446744073709551615: ")+1;
/* Force duplication of payload */
sendflags |= RD_KAFKA_MSG_F_FREE;
}
sbuf = malloc(msgsize);
/* Copy payload content to new buffer */
while (rof < msgsize) {
size_t xlen = RD_MIN(msgsize-rof, plen);
memcpy(sbuf+rof, msgpattern, xlen);
rof += xlen;
}
if (msgcnt == -1)
printf("%% Sending messages of size %i bytes\n",
msgsize);
else
printf("%% Sending %i messages of size %i bytes\n",
msgcnt, msgsize);
/* Create Kafka handle */
if (!(rk = rd_kafka_new(RD_KAFKA_PRODUCER, conf,
errstr, sizeof(errstr)))) {
fprintf(stderr,
"%% Failed to create Kafka producer: %s\n",
errstr);
exit(1);
}
if (debug)
rd_kafka_set_log_level(rk, 7);
/* Add broker(s) */
if (rd_kafka_brokers_add(rk, brokers) < 1) {
fprintf(stderr, "%% No valid brokers specified\n");
exit(1);
}
/* Explicitly create topic to avoid per-msg lookups. */
rkt = rd_kafka_topic_new(rk, topic, topic_conf);
cnt.t_start = rd_clock();
while (run && (msgcnt == -1 || cnt.msgs < msgcnt)) {
/* Send/Produce message. */
if (idle) {
rd_kafka_poll(rk, 1000);
continue;
}
if (do_seq) {
snprintf(sbuf, msgsize-1, "%"PRIu64": ", seq);
seq++;
}
if (sendflags & RD_KAFKA_MSG_F_FREE) {
/* Duplicate memory */
pbuf = malloc(msgsize);
memcpy(pbuf, sbuf, msgsize);
} else
pbuf = sbuf;
cnt.tx++;
while (run &&
rd_kafka_produce(rkt, partition,
sendflags, pbuf, msgsize,
key, keylen, NULL) == -1) {
if (errno == ESRCH)
printf("No such partition: %"PRId32"\n",
partition);
else if (!quiet || errno != ENOBUFS)
printf("produce error: %s%s\n",
strerror(errno),
errno == ENOBUFS ?
" (backpressure)":"");
msgs_failed++;
cnt.tx_err++;
if (errno != ENOBUFS) {
run = 0;
break;
}
now = rd_clock();
if (cnt.t_last + dispintvl <= now) {
printf("%% Backpressure %i "
"(tx %"PRIu64", "
"txerr %"PRIu64")\n",
rd_kafka_outq_len(rk),
cnt.tx, cnt.tx_err);
cnt.t_last = now;
}
/* Poll to handle delivery reports */
rd_kafka_poll(rk, 10);
}
msgs_wait_cnt++;
cnt.msgs++;
cnt.bytes += msgsize;
print_stats(mode, 0, compression);
/* Must poll to handle delivery reports */
rd_kafka_poll(rk, 0);
}
forever = 0;
printf("All messages produced, "
"now waiting for %li deliveries\n",
msgs_wait_cnt);
rd_kafka_dump(stdout, rk);
/* Wait for messages to be delivered */
i = 0;
while (run && rd_kafka_poll(rk, 1000) != -1) {
if (!(i++ % (dispintvl/1000)))
printf("%% Waiting for %li, "
"%i messages in outq "
"to be sent. Abort with Ctrl-c\n",
msgs_wait_cnt,
rd_kafka_outq_len(rk));
}
outq = rd_kafka_outq_len(rk);
printf("%% %i messages in outq\n", outq);
cnt.msgs -= outq;
cnt.bytes -= msgsize * outq;
cnt.t_end = t_end;
if (cnt.tx_err > 0)
printf("%% %"PRIu64" backpressures for %"PRIu64
" produce calls: %.3f%% backpressure rate\n",
cnt.tx_err, cnt.tx,
((double)cnt.tx_err / (double)cnt.tx) * 100.0);
rd_kafka_dump(stdout, rk);
/* Destroy the handle */
rd_kafka_destroy(rk);
} else if (mode == 'C') {
/*
* Consumer
*/
rd_kafka_message_t **rkmessages = NULL;
#if 0 /* Future API */
/* The offset storage file is optional but its presence
* avoids starting all over from offset 0 again when
* the program restarts.
* ZooKeeper functionality will be implemented in future
* versions and then the offset will be stored there instead. */
conf.consumer.offset_file = "."; /* current directory */
/* Indicate to rdkafka that the application is responsible
* for storing the offset. This allows the application to
* successfully handle a message before storing the offset.
* If this flag is not set rdkafka will store the offset
* just prior to returning the message from rd_kafka_consume().
*/
conf.flags |= RD_KAFKA_CONF_F_APP_OFFSET_STORE;
#endif
/* Create Kafka handle */
if (!(rk = rd_kafka_new(RD_KAFKA_CONSUMER, conf,
errstr, sizeof(errstr)))) {
fprintf(stderr,
"%% Failed to create Kafka consumer: %s\n",
errstr);
exit(1);
}
if (debug)
rd_kafka_set_log_level(rk, 7);
/* Add broker(s) */
if (rd_kafka_brokers_add(rk, brokers) < 1) {
fprintf(stderr, "%% No valid brokers specified\n");
exit(1);
}
/* Create topic to consume from */
rkt = rd_kafka_topic_new(rk, topic, topic_conf);
/* Batch consumer */
if (batch_size)
rkmessages = malloc(sizeof(*rkmessages) * batch_size);
/* Start consuming */
if (rd_kafka_consume_start(rkt, partition, start_offset) == -1) {
fprintf(stderr, "%% Failed to start consuming: %s\n",
strerror(errno));
exit(1);
}
cnt.t_start = rd_clock();
while (run && (msgcnt == -1 || msgcnt > cnt.msgs)) {
/* Consume messages.
* A message may either be a real message, or
* an error signaling (if rkmessage->err is set).
*/
uint64_t latency;
int r;
latency = rd_clock();
if (batch_size) {
int i;
/* Batch fetch mode */
r = rd_kafka_consume_batch(rkt, partition,
1000,
rkmessages,
batch_size);
if (r != -1) {
for (i = 0 ; i < r ; i++) {
msg_consume(rkmessages[i],NULL);
rd_kafka_message_destroy(
rkmessages[i]);
}
}
} else {
/* Callback mode */
r = rd_kafka_consume_callback(rkt, partition,
1000/*timeout*/,
msg_consume,
NULL);
}
cnt.t_latency += rd_clock() - latency;
if (r == -1)
fprintf(stderr, "%% Error: %s\n",
strerror(errno));
print_stats(mode, 0, compression);
/* Poll to handle stats callbacks */
rd_kafka_poll(rk, 0);
}
cnt.t_end = rd_clock();
/* Stop consuming */
rd_kafka_consume_stop(rkt, partition);
/* Destroy topic */
rd_kafka_topic_destroy(rkt);
if (batch_size)
free(rkmessages);
/* Destroy the handle */
rd_kafka_destroy(rk);
}
print_stats(mode, 1, compression);
if (cnt.t_latency && cnt.msgs)
printf("%% Average application fetch latency: %"PRIu64"us\n",
cnt.t_latency / cnt.msgs);
/* Let background threads clean up and terminate cleanly. */
rd_kafka_wait_destroyed(2000);
return 0;
}
/* information are parsed but not all are used in our case, ie. for xenstat */
int parseNetDevLine(char *line, char *iface, unsigned long long *rxBytes, unsigned long long *rxPackets,
unsigned long long *rxErrs, unsigned long long *rxDrops, unsigned long long *rxFifo,
unsigned long long *rxFrames, unsigned long long *rxComp, unsigned long long *rxMcast,
unsigned long long *txBytes, unsigned long long *txPackets, unsigned long long *txErrs,
unsigned long long *txDrops, unsigned long long *txFifo, unsigned long long *txColls,
unsigned long long *txCarrier, unsigned long long *txComp)
{
/* Temporary/helper variables */
int ret;
char *tmp;
int i = 0, x = 0, col = 0;
regex_t r;
regmatch_t matches[19];
int num = 19;
/* Regular exception to parse all the information from /proc/net/dev line */
char *regex = "([^:]*):([^ ]*)[ ]*([^ ]*)[ ]*([^ ]*)[ ]*([^ ]*)[ ]*([^ ]*)[ ]*([^ ]*)"
"[ ]*([^ ]*)[ ]*([^ ]*)[ ]*([^ ]*)[ ]*([^ ]*)[ ]*([^ ]*)[ ]*([^ ]*)[ ]*"
"([^ ]*)[ ]*([^ ]*)[ ]*([^ ]*)[ ]*([^ ]*)[ ]*([^ ]*)";
/* Initialize all variables called has passed as non-NULL to zeros */
if (iface != NULL)
memset(iface, 0, sizeof(*iface));
if (rxBytes != NULL)
*rxBytes = 0;
if (rxPackets != NULL)
*rxPackets = 0;
if (rxErrs != NULL)
*rxErrs = 0;
if (rxDrops != NULL)
*rxDrops = 0;
if (rxFifo != NULL)
*rxFifo = 0;
if (rxFrames != NULL)
*rxFrames = 0;
if (rxPackets != NULL)
*rxPackets = 0;
if (rxComp != NULL)
*rxComp = 0;
if (txBytes != NULL)
*txBytes = 0;
if (txPackets != NULL)
*txPackets = 0;
if (txErrs != NULL)
*txErrs = 0;
if (txDrops != NULL)
*txDrops = 0;
if (txFifo != NULL)
*txFifo = 0;
if (txColls != NULL)
*txColls = 0;
if (txCarrier != NULL)
*txCarrier = 0;
if (txComp != NULL)
*txComp = 0;
if ((ret = regcomp(&r, regex, REG_EXTENDED))) {
regfree(&r);
return ret;
}
tmp = (char *)malloc( sizeof(char) );
if (regexec (&r, line, num, matches, REG_EXTENDED) == 0){
for (i = 1; i < num; i++) {
/* The expression matches are empty sometimes so we need to check it first */
if (matches[i].rm_eo - matches[i].rm_so > 0) {
/* Col variable contains current id of non-empty match */
col++;
tmp = (char *)realloc(tmp, (matches[i].rm_eo -
matches[i].rm_so + 1) * sizeof(char));
for (x = matches[i].rm_so; x < matches[i].rm_eo; x++)
tmp[x - matches[i].rm_so] = line[x];
/* We populate all the fields from /proc/net/dev line */
if (i > 1) {
unsigned long long ullTmp = strtoull(tmp, NULL, 10);
switch (col) {
case 2: if (rxBytes != NULL)
*rxBytes = ullTmp;
break;
case 3: if (rxPackets != NULL)
*rxPackets = ullTmp;
break;
case 4: if (rxErrs != NULL)
*rxErrs = ullTmp;
break;
case 5: if (rxDrops != NULL)
*rxDrops = ullTmp;
break;
case 6: if (rxFifo != NULL)
*rxFifo = ullTmp;
break;
case 7: if (rxFrames != NULL)
*rxFrames = ullTmp;
break;
case 8: if (rxComp != NULL)
*rxComp = ullTmp;
break;
case 9: if (rxMcast != NULL)
*rxMcast = ullTmp;
break;
case 10: if (txBytes != NULL)
*txBytes = ullTmp;
break;
case 11: if (txPackets != NULL)
*txPackets = ullTmp;
break;
case 12: if (txErrs != NULL)
*txErrs = ullTmp;
break;
case 13: if (txDrops != NULL)
*txDrops = ullTmp;
break;
case 14: if (txFifo != NULL)
*txFifo = ullTmp;
break;
case 15: if (txColls != NULL)
*txColls = ullTmp;
break;
case 16: if (txCarrier != NULL)
*txCarrier = ullTmp;
break;
case 17: if (txComp != NULL)
*txComp = ullTmp;
break;
}
}
else
/* There were errors when parsing this directly in RE. strpbrk() helps */
if (iface != NULL) {
char *tmp2 = strpbrk(tmp, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");
if (tmp2 != NULL)
strcpy(iface, tmp2);
}
memset(tmp, 0, matches[i].rm_eo - matches[i].rm_so);
}
}
}
free(tmp);
regfree(&r);
return 0;
}
void cpu_linux::measurement_start(void)
{
ifstream file;
DIR *dir;
struct dirent *entry;
char filename[256];
int len;
unsigned int i;
abstract_cpu::measurement_start();
len = sprintf(filename, "/sys/devices/system/cpu/cpu%i/cpuidle", number);
dir = opendir(filename);
if (!dir)
return;
/* For each C-state, there is a stateX directory which
* contains a 'usage' and a 'time' (duration) file */
while ((entry = readdir(dir))) {
char linux_name[64];
char human_name[64];
uint64_t usage = 0;
uint64_t duration = 0;
if (strlen(entry->d_name) < 3)
continue;
strcpy(linux_name, entry->d_name);
strcpy(human_name, linux_name);
sprintf(filename + len, "/%s/name", entry->d_name);
file.open(filename, ios::in);
if (file) {
file.getline(human_name, 64);
file.close();
}
if (strcmp(human_name, "C0")==0)
strcpy(human_name, _("C0 polling"));
sprintf(filename + len, "/%s/usage", entry->d_name);
file.open(filename, ios::in);
if (file) {
file >> usage;
file.close();
}
sprintf(filename + len, "/%s/time", entry->d_name);
file.open(filename, ios::in);
if (file) {
file >> duration;
file.close();
}
update_cstate(linux_name, human_name, usage, duration, 1);
}
closedir(dir);
last_stamp = 0;
for (i = 0; i < children.size(); i++)
if (children[i])
children[i]->wiggle();
sprintf(filename, "/sys/devices/system/cpu/cpu%i/cpufreq/stats/time_in_state", first_cpu);
file.open(filename, ios::in);
if (file) {
char line[1024];
while (file) {
uint64_t f;
file.getline(line, 1024);
f = strtoull(line, NULL, 10);
account_freq(f, 0);
}
file.close();
}
account_freq(0, 0);
}
int ipsw_get_latest_fw(plist_t version_data, const char* product, char** fwurl, unsigned char* sha1buf)
{
*fwurl = NULL;
if (sha1buf != NULL) {
memset(sha1buf, '\0', 20);
}
plist_t n1 = plist_dict_get_item(version_data, "MobileDeviceSoftwareVersionsByVersion");
if (!n1) {
error("%s: ERROR: Can't find MobileDeviceSoftwareVersionsByVersion dict in version data\n", __func__);
return -1;
}
plist_dict_iter iter = NULL;
plist_dict_new_iter(n1, &iter);
if (!iter) {
error("%s: ERROR: Can't get dict iter\n", __func__);
return -1;
}
char* key = NULL;
long long unsigned int major = 0;
plist_t val = NULL;
do {
plist_dict_next_item(n1, iter, &key, &val);
if (key) {
plist_t pr = plist_access_path(n1, 3, key, "MobileDeviceSoftwareVersions", product);
if (pr) {
long long unsigned int v = strtoull(key, NULL, 10);
if (v > major)
major = v;
}
free(key);
}
} while (val);
free(iter);
if (major == 0) {
error("%s: ERROR: Can't find major version?!\n", __func__);
return -1;
}
char majstr[32]; // should be enough for a uint64_t value
sprintf(majstr, FMT_qu, (long long unsigned int)major);
n1 = plist_access_path(version_data, 7, "MobileDeviceSoftwareVersionsByVersion", majstr, "MobileDeviceSoftwareVersions", product, "Unknown", "Universal", "Restore");
if (!n1) {
error("%s: ERROR: Can't get Unknown/Universal/Restore node?!\n", __func__);
return -1;
}
plist_t n2 = plist_dict_get_item(n1, "BuildVersion");
if (!n2 || (plist_get_node_type(n2) != PLIST_STRING)) {
error("%s: ERROR: Can't get build version node?!\n", __func__);
return -1;
}
char* strval = NULL;
plist_get_string_val(n2, &strval);
n1 = plist_access_path(version_data, 5, "MobileDeviceSoftwareVersionsByVersion", majstr, "MobileDeviceSoftwareVersions", product, strval);
if (!n1) {
error("%s: ERROR: Can't get MobileDeviceSoftwareVersions/%s node?!\n", __func__, strval);
free(strval);
return -1;
}
free(strval);
strval = NULL;
n2 = plist_dict_get_item(n1, "SameAs");
if (n2) {
plist_get_string_val(n2, &strval);
}
if (strval) {
n1 = plist_access_path(version_data, 5, "MobileDeviceSoftwareVersionsByVersion", majstr, "MobileDeviceSoftwareVersions", product, strval);
free(strval);
strval = NULL;
if (!n1 || (plist_dict_get_size(n1) == 0)) {
error("%s: ERROR: Can't get MobileDeviceSoftwareVersions/%s dict\n", __func__, product);
return -1;
}
}
n2 = plist_access_path(n1, 2, "Update", "BuildVersion");
if (n2) {
strval = NULL;
plist_get_string_val(n2, &strval);
if (strval) {
n1 = plist_access_path(version_data, 5, "MobileDeviceSoftwareVersionsByVersion", majstr, "MobileDeviceSoftwareVersions", product, strval);
free(strval);
strval = NULL;
}
}
n2 = plist_access_path(n1, 2, "Restore", "FirmwareURL");
if (!n2 || (plist_get_node_type(n2) != PLIST_STRING)) {
error("%s: ERROR: Can't get FirmwareURL node\n", __func__);
return -1;
}
plist_get_string_val(n2, fwurl);
if (sha1buf != NULL) {
n2 = plist_access_path(n1, 2, "Restore", "FirmwareSHA1");
if (n2 && plist_get_node_type(n2) == PLIST_STRING) {
strval = NULL;
plist_get_string_val(n2, &strval);
if (strval) {
if (strlen(strval) == 40) {
int i;
int v;
for (i = 0; i < 40; i+=2) {
v = 0;
sscanf(strval+i, "%02x", &v);
sha1buf[i/2] = (unsigned char)v;
}
}
free(strval);
}
}
}
return 0;
}
// **************************************************************************
// HTTPヘッダを受信して解析する。
//
// 処理するのはGETのみ。GET以外のメソッドが来たらエラー
// 今のところ、URIとuser_agent、Range、Hostを解析。
// URIは、URIデコードもやる。
//
// return: 0 正常終了
// return: 0以外 エラー
// **************************************************************************
static int http_header_receive(int accept_socket, HTTP_RECV_INFO *http_recv_info_p)
{
int result = 0;
int recv_len;
char line_buf[1024]; // 大きめに。
char work_buf[1024];
char work_buf2[1024];
char split1[1024];
char split2[1024];
int ret;
int i;
// ================================
// １行づつ HTTPヘッダを受信
// ================================
for (i=0;;i++){
// 1行受信 実行。
recv_len = line_receive(accept_socket, line_buf, sizeof(line_buf));
// 受信した内容をチェック。
if ( recv_len == 0 ){ // 空行検知。ヘッダ受信終了。
break;
}else if ( recv_len < 0 ){ // 受信失敗
return ( -1 );
}
// debug. 受信したヘッダ表示
debug_log_output("'%s'(%d byte)\n", line_buf, recv_len );
// --------------------------
// GETメッセージチェック
// --------------------------
if ( i == 0 ){ // １行目のみチェック
debug_log_output("%d:URI Check start.'%s'\n", accept_socket,line_buf);
// GETある？
if ( strstr(line_buf, "GET") != NULL ){
http_recv_info_p->isGet = 1;
}else if ( strstr(line_buf, "HEAD") != NULL ){
http_recv_info_p->isGet = 2;
}else if ( strstr(line_buf, "POST") != NULL ){
http_recv_info_p->isGet = 3;
}else{
debug_log_output("'GET' not found. error.%d",accept_socket);
return ( -1 );
}
// 最初のスペースまでを削除。
cut_before_character(line_buf, ' ');
// 次にスペースが出てきたところの後ろまでを削除。
cut_after_character(line_buf, ' ');
// ===========================
// GETオプション部解析
// ===========================
// REQUEST_URI用・Proxy用に値を保存
strncpy(http_recv_info_p->request_uri, line_buf, sizeof(http_recv_info_p->request_uri));
// '?'が存在するかチェック。
if ( strchr(line_buf, '?') != NULL ){
strncpy(work_buf, line_buf, sizeof(work_buf));
// '?'より前をカット
cut_before_character(work_buf, '?' );
while ( 1 ){
memset(split1, 0, sizeof(split1));
memset(split2, 0, sizeof(split2));
// 最初に登場する'&'で分割
ret = sentence_split(work_buf, '&', split1, split2 );
if ( ret == 0 ){ // 分割成功
strncpy(work_buf, split2, sizeof(work_buf));
}else if (strlen(work_buf) > 0){ // まだwork_bufに中身ある？
strncpy( split1, work_buf, sizeof(split1));
strncpy( work_buf, "", sizeof(work_buf));
}else{ // 処理終了
break;
}
// -------------------------------------
// GETした内容 解析開始
// 超安直。いいのかこんな比較で。
// -------------------------------------
// URIデコード
uri_decode(work_buf2, sizeof(work_buf2), split1, sizeof(split1) );
// "action="あるか調査。
if (strncasecmp( work_buf2, "action=", strlen("action=") ) == 0 ){
// = より前を削除
cut_before_character(work_buf2, '=');
// 構造体に値を保存。
strncpy(http_recv_info_p->action, work_buf2, sizeof(http_recv_info_p->action));
continue;
}
}
}
debug_log_output("http_recv_info_p->action = '%s'", http_recv_info_p->action);
// URIデコード
cut_after_character(line_buf, '?');
uri_decode(work_buf, sizeof(work_buf), line_buf, sizeof(line_buf) );
strncpy(line_buf, work_buf, sizeof(line_buf));
debug_log_output("URI(decoded):'%s'\n", line_buf);
convert_language_code(line_buf, work_buf, sizeof(work_buf), CODE_AUTO, CODE_EUC);
debug_log_output("URI(decoded,euc,FYI):'%s'\n", work_buf);
// 構造体に保存
strncpy(http_recv_info_p->recv_uri, line_buf, sizeof(http_recv_info_p->recv_uri));
//httpから始まってる場合には、http://以降の最初の'/'の前でカット
if( strncmp(http_recv_info_p->recv_uri,"http://",7)==0){
char* ptr = strstr(http_recv_info_p->recv_uri+7,"/");
if( ptr ){
strcpy(http_recv_info_p->recv_uri,ptr);
}
}
continue;
}
// User-agent切り出し
if ( strncasecmp(line_buf, HTTP_USER_AGENT, strlen(HTTP_USER_AGENT) ) == 0 ){
debug_log_output("User-agent: Detect.\n");
// ':'より前を切る
cut_before_character(line_buf, ':');
cut_first_character(line_buf, ' ');
// 構造体に保存
strncpy( http_recv_info_p->user_agent, line_buf, sizeof(http_recv_info_p->user_agent));
continue;
}
// Rangeあるかチェック
if ( strncasecmp(line_buf, HTTP_RANGE, strlen(HTTP_RANGE) ) == 0 ){
debug_log_output("%s Detect.\n", HTTP_RANGE);
// ':' より前を切る。
cut_before_character(line_buf, ':');
cut_first_character(line_buf, ' ');
// recv_range にRangeの中身保存
strncpy(http_recv_info_p->recv_range, line_buf, sizeof(http_recv_info_p->recv_range));
// '=' より前を切る
cut_before_character(line_buf, '=');
// '-'で前後に分割。
sentence_split(line_buf, '-', work_buf, work_buf2);
debug_log_output("wrok_buf='%s'\n", work_buf);
debug_log_output("wrok_buf2='%s'\n", work_buf2);
// 値を文字列→数値変換
http_recv_info_p->range_start_pos = strtoull(work_buf, NULL, 10);
if ( strlen(work_buf2) > 0 ){
http_recv_info_p->range_end_pos = strtoull(work_buf2, NULL, 10);
}
debug_log_output("range_start_pos=%d\n", http_recv_info_p->range_start_pos);
debug_log_output("range_end_pos=%d\n", http_recv_info_p->range_end_pos);
continue;
}
// Hostあるかチェック
if ( strncasecmp(line_buf, HTTP_HOST, strlen(HTTP_HOST) ) == 0 ){
// ':' より前を切る。
cut_before_character(line_buf, ':');
cut_first_character(line_buf, ' ');
strncpy(http_recv_info_p->recv_host, line_buf, sizeof(http_recv_info_p->recv_host));
debug_log_output("%s Detect. %s '%s'", HTTP_HOST, HTTP_HOST, http_recv_info_p->recv_host);
continue;
}
// Content-Lengthあるかチェック
if ( strncasecmp(line_buf, HTTP_CONTENT_LENGTH1, strlen(HTTP_CONTENT_LENGTH1) ) == 0 ){
// ':' より前を切る。
cut_before_character(line_buf, ':');
cut_first_character(line_buf, ' ');
strncpy(http_recv_info_p->content_length, line_buf, sizeof(http_recv_info_p->content_length));
debug_log_output("%s Detect. %s '%s'", HTTP_CONTENT_LENGTH1, HTTP_CONTENT_LENGTH1, http_recv_info_p->content_length);
continue;
}
// Content-TYPEあるかチェック
if ( strncasecmp(line_buf, HTTP_CONTENT_TYPE1, strlen(HTTP_CONTENT_TYPE1) ) == 0 ){
// ':' より前を切る。
cut_before_character(line_buf, ':');
cut_first_character(line_buf, ' ');
strncpy(http_recv_info_p->content_type, line_buf, sizeof(http_recv_info_p->content_type));
debug_log_output("%s Detect. %s '%s'", HTTP_CONTENT_TYPE1, HTTP_CONTENT_TYPE1, http_recv_info_p->content_type);
continue;
}
}
return result;
}
void cpu_linux::measurement_end(void)
{
DIR *dir;
struct dirent *entry;
char filename[256];
ifstream file;
int len;
len = sprintf(filename, "/sys/devices/system/cpu/cpu%i/cpuidle", number);
dir = opendir(filename);
if (!dir)
return;
/* For each C-state, there is a stateX directory which
* contains a 'usage' and a 'time' (duration) file */
while ((entry = readdir(dir))) {
char linux_name[64];
char human_name[64];
uint64_t usage = 0;
uint64_t duration = 0;
if (strlen(entry->d_name) < 3)
continue;
strcpy(linux_name, entry->d_name);
strcpy(human_name, linux_name);
sprintf(filename + len, "/%s/usage", entry->d_name);
file.open(filename, ios::in);
if (file) {
file >> usage;
file.close();
}
sprintf(filename + len, "/%s/time", entry->d_name);
file.open(filename, ios::in);
if (file) {
file >> duration;
file.close();
}
finalize_cstate(linux_name, usage, duration, 1);
}
closedir(dir);
sprintf(filename, "/sys/devices/system/cpu/cpu%i/cpufreq/stats/time_in_state", number);
file.open(filename, ios::in);
if (file) {
char line[1024];
while (file) {
uint64_t f,count;
char *c;
memset(line, 0, 1024);
file.getline(line, 1024);
f = strtoull(line, &c, 10);
if (!c)
break;
count = strtoull(c, NULL, 10);
if (f > 0)
finalize_pstate(f, count, 1);
}
file.close();
}
abstract_cpu::measurement_end();
}
/*
* Parse /proc/self/numa_maps to get the NUMA socket ID for each huge
* page.
*/
static int
find_numasocket(struct hugepage_file *hugepg_tbl, struct hugepage_info *hpi)
{
int socket_id;
char *end, *nodestr;
unsigned i, hp_count = 0;
uint64_t virt_addr;
char buf[BUFSIZ];
char hugedir_str[PATH_MAX];
FILE *f;
f = fopen("/proc/self/numa_maps", "r");
if (f == NULL) {
RTE_LOG(NOTICE, EAL, "cannot open /proc/self/numa_maps,"
" consider that all memory is in socket_id 0\n");
return 0;
}
snprintf(hugedir_str, sizeof(hugedir_str),
"%s/%s", hpi->hugedir, internal_config.hugefile_prefix);
/* parse numa map */
while (fgets(buf, sizeof(buf), f) != NULL) {
/* ignore non huge page */
if (strstr(buf, " huge ") == NULL &&
strstr(buf, hugedir_str) == NULL)
continue;
/* get zone addr */
virt_addr = strtoull(buf, &end, 16);
if (virt_addr == 0 || end == buf) {
RTE_LOG(ERR, EAL, "%s(): error in numa_maps parsing\n", __func__);
goto error;
}
/* get node id (socket id) */
nodestr = strstr(buf, " N");
if (nodestr == NULL) {
RTE_LOG(ERR, EAL, "%s(): error in numa_maps parsing\n", __func__);
goto error;
}
nodestr += 2;
end = strstr(nodestr, "=");
if (end == NULL) {
RTE_LOG(ERR, EAL, "%s(): error in numa_maps parsing\n", __func__);
goto error;
}
end[0] = '\0';
end = NULL;
socket_id = strtoul(nodestr, &end, 0);
if ((nodestr[0] == '\0') || (end == NULL) || (*end != '\0')) {
RTE_LOG(ERR, EAL, "%s(): error in numa_maps parsing\n", __func__);
goto error;
}
/* if we find this page in our mappings, set socket_id */
for (i = 0; i < hpi->num_pages[0]; i++) {
void *va = (void *)(unsigned long)virt_addr;
if (hugepg_tbl[i].orig_va == va) {
hugepg_tbl[i].socket_id = socket_id;
hp_count++;
}
}
}
if (hp_count < hpi->num_pages[0])
goto error;
fclose(f);
return 0;
error:
fclose(f);
return -1;
}
static int
cpu_n2_mdesc_init(topo_mod_t *mod, md_t *mdp, md_info_t *chip)
{
mde_cookie_t *list1p, *list2p;
md_cpumap_t *mcmp;
md_proc_t *procp;
md_fru_t *frup;
int i, j, cnt;
int procid_flag = 0;
int nnode, ncomp, nproc, ncpu;
char *str = NULL;
uint64_t x, sn;
char *strserial, *end;
nnode = md_node_count(mdp);
list1p = topo_mod_zalloc(mod, sizeof (mde_cookie_t) * nnode);
/* Count the number of processors and strands */
ncomp = md_scan_dag(mdp,
MDE_INVAL_ELEM_COOKIE,
md_find_name(mdp, MD_STR_COMPONENT),
md_find_name(mdp, "fwd"),
list1p);
if (ncomp <= 0) {
topo_mod_dprintf(mod, "Component nodes not found\n");
topo_mod_free(mod, list1p, sizeof (mde_cookie_t) * nnode);
return (-1);
}
for (i = 0, nproc = 0, ncpu = 0; i < ncomp; i++) {
if (md_get_prop_str(mdp, list1p[i], MD_STR_TYPE, &str) == 0 &&
str != NULL && strcmp(str, MD_STR_PROCESSOR) == 0) {
nproc++;
/* check if the physical id exists */
if (md_get_prop_val(mdp, list1p[i], MD_STR_ID, &x)
== 0) {
procid_flag = 1;
}
}
if (md_get_prop_str(mdp, list1p[i], MD_STR_TYPE, &str) == 0 &&
str && strcmp(str, MD_STR_STRAND) == 0) {
ncpu++;
}
}
topo_mod_dprintf(mod, "Found %d procs and %d strands\n", nproc, ncpu);
if (nproc == 0 || ncpu == 0) {
topo_mod_free(mod, list1p, sizeof (mde_cookie_t) * nnode);
return (-1);
}
/* Alloc processors and strand entries */
list2p = topo_mod_zalloc(mod, sizeof (mde_cookie_t) * 2 * ncpu);
chip->nprocs = nproc;
chip->procs = topo_mod_zalloc(mod, nproc * sizeof (md_proc_t));
chip->ncpus = ncpu;
chip->cpus = topo_mod_zalloc(mod, ncpu * sizeof (md_cpumap_t));
/* Visit each processor node */
procp = chip->procs;
mcmp = chip->cpus;
for (i = 0, nproc = 0, ncpu = 0; i < ncomp; i++) {
if (md_get_prop_str(mdp, list1p[i], MD_STR_TYPE, &str) < 0 ||
str == NULL || strcmp(str, MD_STR_PROCESSOR))
continue;
if (md_get_prop_val(mdp, list1p[i], MD_STR_SERIAL, &sn) < 0) {
if (md_get_prop_str(mdp, list1p[i], MD_STR_SERIAL,
&strserial) < 0) {
topo_mod_dprintf(mod,
"Failed to get the serial number of"
"proc[%d]\n", nproc);
continue;
} else {
sn = (uint64_t)strtoull(strserial, &end, 16);
if (strserial == end) {
topo_mod_dprintf(mod,
"Failed to convert the serial "
"string to serial int of "
"proc[%d]\n", nproc);
continue;
}
}
}
procp->serialno = sn;
/* Assign physical proc id */
procp->id = -1;
if (procid_flag) {
if (md_get_prop_val(mdp, list1p[i], MD_STR_ID, &x)
== 0) {
procp->id = x;
}
} else {
procp->id = nproc;
}
topo_mod_dprintf(mod, "proc %d: sn=%llx, id=%d\n", nproc,
procp->serialno, procp->id);
/* Get all the strands below this proc */
cnt = md_scan_dag(mdp,
list1p[i],
md_find_name(mdp, MD_STR_COMPONENT),
md_find_name(mdp, "fwd"),
list2p);
topo_mod_dprintf(mod, "proc[%llx]: Found %d fwd components\n",
sn, cnt);
if (cnt <= 0) {
nproc++;
procp++;
continue;
}
for (j = 0; j < cnt; j++) {
/* Consider only the strand nodes */
if (md_get_prop_str(mdp, list2p[j], MD_STR_TYPE, &str)
< 0 || str == NULL || strcmp(str, MD_STR_STRAND))
continue;
if (md_get_prop_val(mdp, list2p[j], MD_STR_ID, &x) < 0)
x = (uint64_t)-1; /* invalid value */
mcmp->cpumap_id = x;
if (md_get_prop_val(mdp, list2p[j], MD_STR_PID, &x) < 0)
x = mcmp->cpumap_id;
mcmp->cpumap_pid = x;
mcmp->cpumap_serialno = sn;
mcmp->cpumap_chipidx = nproc;
ncpu++;
mcmp++;
}
/*
* To get the fru of this proc, follow the back arc up to
* find the first node whose fru field is set
*/
cnt = md_scan_dag(mdp,
list1p[i],
md_find_name(mdp, MD_STR_COMPONENT),
md_find_name(mdp, "back"),
list2p);
topo_mod_dprintf(mod, "proc[%d]: Found %d back components\n",
nproc, cnt);
if (cnt <= 0) {
nproc++;
procp++;
continue;
}
for (j = 0; j < cnt; j++) {
/* test the fru field which must be positive number */
if ((md_get_prop_val(mdp, list2p[j], MD_STR_FRU, &x)
== 0) && x > 0)
break;
}
if (j < cnt) {
/* Found the FRU node, get the fru identity */
topo_mod_dprintf(mod, "proc[%d] sn=%llx has a fru %d\n",
nproc, procp->serialno, j);
frup = topo_mod_zalloc(mod, sizeof (md_fru_t));
procp->fru = frup;
if (!md_get_prop_str(mdp, list2p[j], MD_STR_NAC, &str))
frup->nac = topo_mod_strdup(mod, str);
else
frup->nac = topo_mod_strdup(mod, MD_FRU_DEF);
if (!md_get_prop_str(mdp, list2p[j], MD_STR_PART, &str))
frup->part = topo_mod_strdup(mod, str);
if (!md_get_prop_str(mdp, list2p[j], MD_STR_SERIAL,
&str))
frup->serial = topo_mod_strdup(mod, str);
if (!md_get_prop_str(mdp, list2p[j], MD_STR_DASH, &str))
frup->dash = topo_mod_strdup(mod, str);
} else {
topo_mod_dprintf(mod, "proc[%d] sn=%llx has no fru\n",
i, procp->serialno);
}
nproc++;
procp++;
} /* for i */
topo_mod_free(mod, list1p, sizeof (mde_cookie_t) * nnode);
topo_mod_free(mod, list2p, sizeof (mde_cookie_t) * 2*chip->ncpus);
return (0);
}
int
main(int argc, char **argv)
{
INUM_T inum;
int ch;
char *cp, *dash;
char *fstype = NULL;
FS_INFO *fs;
int32_t sec_skew = 0;
char *imgtype = NULL;
IMG_INFO *img;
SSIZE_T imgoff = 0;
/* When > 0 this is the number of blocks to print, used for -b arg */
DADDR_T numblock = 0;
progname = argv[0];
setlocale(LC_ALL, "");
while ((ch = getopt(argc, argv, "b:f:i:o:s:vVz:")) > 0) {
switch (ch) {
case '?':
default:
fprintf(stderr, "Invalid argument: %s\n", argv[optind]);
usage();
case 'b':
numblock = strtoull(optarg, &cp, 0);
if (*cp || cp == optarg || numblock < 1) {
fprintf(stderr,
"invalid argument: block count must be positive: %s\n",
optarg);
usage();
}
break;
case 'f':
fstype = optarg;
break;
case 'i':
imgtype = optarg;
break;
case 'o':
if ((imgoff = parse_offset(optarg)) == -1) {
tsk_error_print(stderr);
exit(1);
}
break;
case 's':
sec_skew = atoi(optarg);
break;
case 'v':
verbose++;
break;
case 'V':
print_version(stdout);
exit(0);
case 'z':
{
char envstr[32];
snprintf(envstr, 32, "TZ=%s", optarg);
if (0 != putenv(envstr)) {
fprintf(stderr, "error setting environment");
exit(1);
}
tzset();
}
break;
}
}
/* We need at least two more argument */
if (optind + 1 >= argc) {
fprintf(stderr, "Missing image name and/or address\n");
usage();
}
/* if we are given the inode in the inode-type-id form, then ignore
* the other stuff w/out giving an error
*
* This will make scripting easier
*/
if ((dash = strchr(argv[argc - 1], '-')) != NULL) {
*dash = '\0';
}
inum = strtoull(argv[argc - 1], &cp, 0);
if (*cp || cp == argv[argc - 1]) {
fprintf(stderr, "bad inode number: %s", argv[argc - 1]);
usage();
}
/*
* Open the file system.
*/
if ((img =
img_open(imgtype, argc - optind - 1,
(const char **) &argv[optind])) == NULL) {
tsk_error_print(stderr);
exit(1);
}
if ((fs = fs_open(img, imgoff, fstype)) == NULL) {
tsk_error_print(stderr);
if (tsk_errno == TSK_ERR_FS_UNSUPTYPE)
fs_print_types(stderr);
img->close(img);
exit(1);
}
if (inum > fs->last_inum) {
fprintf(stderr,
"Metadata address is too large for image (%" PRIuINUM ")\n",
fs->last_inum);
fs->close(fs);
img->close(img);
exit(1);
}
if (inum < fs->first_inum) {
fprintf(stderr,
"Metadata address is too small for image (%" PRIuINUM ")\n",
fs->first_inum);
fs->close(fs);
img->close(img);
exit(1);
}
if (fs->istat(fs, stdout, inum, numblock, sec_skew)) {
tsk_error_print(stderr);
fs->close(fs);
img->close(img);
exit(1);
}
fs->close(fs);
img->close(img);
exit(0);
}
static memcached_return_t textual_value_fetch(memcached_server_write_instance_st ptr,
char *buffer,
memcached_result_st *result)
{
memcached_return_t rc= MEMCACHED_SUCCESS;
char *string_ptr;
char *end_ptr;
char *next_ptr;
size_t value_length;
size_t to_read;
char *value_ptr;
ssize_t read_length= 0;
memcached_return_t rrc;
if (ptr->root->flags.use_udp)
return MEMCACHED_NOT_SUPPORTED;
WATCHPOINT_ASSERT(ptr->root);
end_ptr= buffer + MEMCACHED_DEFAULT_COMMAND_SIZE;
memcached_result_reset(result);
string_ptr= buffer;
string_ptr+= 6; /* "VALUE " */
/* We load the key */
{
char *key;
size_t prefix_length;
key= result->item_key;
result->key_length= 0;
for (prefix_length= ptr->root->prefix_key_length; !(iscntrl(*string_ptr) || isspace(*string_ptr)) ; string_ptr++)
{
if (prefix_length == 0)
{
*key= *string_ptr;
key++;
result->key_length++;
}
else
prefix_length--;
}
result->item_key[result->key_length]= 0;
}
if (end_ptr == string_ptr)
goto read_error;
/* Flags fetch move past space */
string_ptr++;
if (end_ptr == string_ptr)
goto read_error;
for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++);
result->item_flags= (uint32_t) strtoul(next_ptr, &string_ptr, 10);
if (end_ptr == string_ptr)
goto read_error;
/* Length fetch move past space*/
string_ptr++;
if (end_ptr == string_ptr)
goto read_error;
for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++);
value_length= (size_t)strtoull(next_ptr, &string_ptr, 10);
if (end_ptr == string_ptr)
goto read_error;
/* Skip spaces */
if (*string_ptr == '\r')
{
/* Skip past the \r\n */
string_ptr+= 2;
}
else
{
string_ptr++;
for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++);
result->item_cas= strtoull(next_ptr, &string_ptr, 10);
}
if (end_ptr < string_ptr)
goto read_error;
/* We add two bytes so that we can walk the \r\n */
rc= memcached_string_check(&result->value, value_length+2);
if (rc != MEMCACHED_SUCCESS)
{
value_length= 0;
return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
}
value_ptr= memcached_string_value_mutable(&result->value);
/*
We read the \r\n into the string since not doing so is more
cycles then the waster of memory to do so.
We are null terminating through, which will most likely make
some people lazy about using the return length.
*/
to_read= (value_length) + 2;
rrc= memcached_io_read(ptr, value_ptr, to_read, &read_length);
if (rrc != MEMCACHED_SUCCESS)
return rrc;
if (read_length != (ssize_t)(value_length + 2))
{
goto read_error;
}
/* This next bit blows the API, but this is internal....*/
{
char *char_ptr;
char_ptr= memcached_string_value_mutable(&result->value);;
char_ptr[value_length]= 0;
char_ptr[value_length + 1]= 0;
memcached_string_set_length(&result->value, value_length);
}
return MEMCACHED_SUCCESS;
read_error:
memcached_io_reset(ptr);
return MEMCACHED_PARTIAL_READ;
}
//move selected object
static bool HandleGameObjectMoveCommand(ChatHandler* handler, char const* args)
{
// number or [name] Shift-click form |color|Hgameobject:go_guid|h[name]|h|r
char* id = handler->extractKeyFromLink((char*)args, "Hgameobject");
if (!id)
return false;
ObjectGuid::LowType guidLow = strtoull(id, nullptr, 10);
if (!guidLow)
return false;
GameObject* object = NULL;
// by DB guid
if (GameObjectData const* gameObjectData = sObjectMgr->GetGOData(guidLow))
object = handler->GetObjectGlobalyWithGuidOrNearWithDbGuid(guidLow, gameObjectData->id);
if (!object)
{
handler->PSendSysMessage(LANG_COMMAND_OBJNOTFOUND, guidLow);
handler->SetSentErrorMessage(true);
return false;
}
char* toX = strtok(NULL, " ");
char* toY = strtok(NULL, " ");
char* toZ = strtok(NULL, " ");
float x, y, z;
if (!toX)
{
Player* player = handler->GetSession()->GetPlayer();
player->GetPosition(x, y, z);
}
else
{
if (!toY || !toZ)
return false;
x = (float)atof(toX);
y = (float)atof(toY);
z = (float)atof(toZ);
if (!MapManager::IsValidMapCoord(object->GetMapId(), x, y, z))
{
handler->PSendSysMessage(LANG_INVALID_TARGET_COORD, x, y, object->GetMapId());
handler->SetSentErrorMessage(true);
return false;
}
}
object->DestroyForNearbyPlayers();
object->RelocateStationaryPosition(x, y, z, object->GetOrientation());
object->GetMap()->GameObjectRelocation(object, x, y, z, object->GetOrientation());
object->SaveToDB();
handler->PSendSysMessage(LANG_COMMAND_MOVEOBJMESSAGE, object->GetSpawnId(), object->GetGOInfo()->name.c_str(), object->GetGUID().ToString().c_str());
return true;
}
/*
* This example shows how to retrieve the PMU register mapping information.
* It does not use the libpfm library.
* The mapping gives the translation between the logical register names,
* as exposed by the perfmon interface, and the actual hardware registers.
* Depending on the PMU and perfmon implementation, not all registers are
* necessarily PMU registers, some may correspond to software resources.
*/
int
main(int argc, char **argv)
{
unsigned long long dfl, rsvd;
unsigned long hw_addr;
pfarg_ctx_t ctx;
char pname[64];
char name[64], buffer[32];
unsigned int i, num_pmcs = 0, num_pmds = 0;
int c, ret, ret2 = 0;
int use_html = 0;
while((c=getopt(argc, argv, "hH")) != -1) {
switch(c) {
case 'h':
printf("usage: showreginfo [-h] [-H]\n");
return 0;
case 'H':
use_html = 1;
break;
default:
return -1;
}
}
try_again:
ret = get_value("/sys/kernel/perfmon/pmu_desc/model", buffer, sizeof(buffer));
if (ret == -1) {
/*
* try to trigger automatic PMU description loading
*/
if (ret2 == 0) {
memset(&ctx, 0, sizeof(ctx));
ret2 = pfm_create(0, NULL);
if (ret2 > -1) {
close(ret2);
goto try_again;
}
fatal_error("invalid or missing perfmon support for your CPU (need at least v3.0)\n");
}
}
if (use_html) {
puts("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
puts("<html>");
puts("<head>");
puts("<body>");
puts("<table border=\"5\" frame=\"border\" rules=\"groups\" width=\"60%\" cellpadding=\"2\" cellspacing=\"0\">");
printf("<caption>%s</caption>\n", buffer);
puts("<thead><tr align=\"left\">");
puts("<th>Name</th><th>HW ADDR</th><th>Description</th>");
puts("<tbody>");
} else {
printf("model : %s\n", buffer);
puts( "----------------------------------------------------------------------------\n"
"name | default value | reserved mask | hw address | description\n"
"-------+--------------------+--------------------+------------+-------------");
}
for(i=0; i < PFM_MAX_PMCS; i++) {
sprintf(pname, "/sys/kernel/perfmon/pmu_desc/pmc%d/name", i);
ret = get_value(pname, name, sizeof(name));
if (ret)
continue;
num_pmcs++;
sprintf(pname, "/sys/kernel/perfmon/pmu_desc/pmc%d/dfl_val", i);
get_value(pname, buffer, sizeof(buffer));
dfl = strtoull(buffer, NULL, 16);
sprintf(pname, "/sys/kernel/perfmon/pmu_desc/pmc%d/rsvd_msk", i);
get_value(pname, buffer, sizeof(buffer));
rsvd = strtoull(buffer, NULL, 16);
sprintf(pname, "/sys/kernel/perfmon/pmu_desc/pmc%d/addr", i);
get_value(pname, buffer, sizeof(buffer));
hw_addr = strtoul(buffer, NULL, 0);
if (use_html) {
printf("<tr> <td>PMC%d</td><td>0x%lx</td><td>%s</td>\n",
i,
hw_addr,
name);
} else {
printf("pmc%-3d | 0x%016llx | 0x%016llx | 0x%-8lx | %s\n",
i,
dfl,
rsvd,
hw_addr,
name);
}
}
if (use_html)
puts("<tbody>");
else
puts("-------+--------------------+--------------------+------------+-------------");
for(i=0; i < PFM_MAX_PMDS; i++) {
sprintf(pname, "/sys/kernel/perfmon/pmu_desc/pmd%d/name", i);
ret = get_value(pname, name, sizeof(name));
if (ret)
continue;
num_pmds++;
sprintf(pname, "/sys/kernel/perfmon/pmu_desc/pmd%d/dfl_val", i);
get_value(pname, buffer, sizeof(buffer));
dfl = strtoull(buffer, NULL, 16);
sprintf(pname, "/sys/kernel/perfmon/pmu_desc/pmd%d/rsvd_msk", i);
get_value(pname, buffer, sizeof(buffer));
rsvd = strtoull(buffer, NULL, 16);
sprintf(pname, "/sys/kernel/perfmon/pmu_desc/pmd%d/addr", i);
get_value(pname, buffer, sizeof(buffer));
hw_addr = strtoul(buffer, NULL, 0);
if (use_html) {
printf("<tr> <td>PMC%d</td><td>0x%lx</td><td>%s</td>\n",
i,
hw_addr,
name);
} else {
printf("pmd%-3d | 0x%016llx | 0x%016llx | 0x%-8lx | %s\n",
i,
dfl,
rsvd,
hw_addr,
name);
}
}
if (use_html) {
puts("</table>");
puts("</body>");
puts("</html>");
} else {
puts("----------------------------------------------------------------------------");
printf("%u PMC registers, %u PMD registers\n", num_pmcs, num_pmds);
}
return 0;
}
void
sink(int argc, char **argv)
{
static BUF buffer;
struct stat stb;
enum {
YES, NO, DISPLAYED
} wrerr;
BUF *bp;
off_t i;
size_t j, count;
int amt, exists, first, ofd;
mode_t mode, omode, mask;
off_t size, statbytes;
unsigned long long ull;
int setimes, targisdir, wrerrno = 0;
char ch, *cp, *np, *targ, *why, *vect[1], buf[2048];
struct timeval tv[2];
#define atime tv[0]
#define mtime tv[1]
#define SCREWUP(str) { why = str; goto screwup; }
setimes = targisdir = 0;
mask = umask(0);
if (!pflag)
(void) umask(mask);
if (argc != 1) {
run_err("ambiguous target");
exit(1);
}
targ = *argv;
if (targetshouldbedirectory)
verifydir(targ);
(void) atomicio(vwrite, remout, "", 1);
if (stat(targ, &stb) == 0 && S_ISDIR(stb.st_mode))
targisdir = 1;
for (first = 1;; first = 0) {
cp = buf;
if (atomicio(read, remin, cp, 1) != 1)
return;
if (*cp++ == '\n')
SCREWUP("unexpected <newline>");
do {
if (atomicio(read, remin, &ch, sizeof(ch)) != sizeof(ch))
SCREWUP("lost connection");
*cp++ = ch;
} while (cp < &buf[sizeof(buf) - 1] && ch != '\n');
*cp = 0;
if (verbose_mode)
fprintf(stderr, "Sink: %s", buf);
if (buf[0] == '\01' || buf[0] == '\02') {
if (iamremote == 0)
(void) atomicio(vwrite, STDERR_FILENO,
buf + 1, strlen(buf + 1));
if (buf[0] == '\02')
exit(1);
++errs;
continue;
}
if (buf[0] == 'E') {
(void) atomicio(vwrite, remout, "", 1);
return;
}
if (ch == '\n')
*--cp = 0;
cp = buf;
if (*cp == 'T') {
setimes++;
cp++;
if (!isdigit((unsigned char)*cp))
SCREWUP("mtime.sec not present");
ull = strtoull(cp, &cp, 10);
if (!cp || *cp++ != ' ')
SCREWUP("mtime.sec not delimited");
if ((time_t)ull < 0 ||
(unsigned long long)(time_t)ull != ull)
setimes = 0; /* out of range */
mtime.tv_sec = ull;
mtime.tv_usec = strtol(cp, &cp, 10);
if (!cp || *cp++ != ' ' || mtime.tv_usec < 0 ||
mtime.tv_usec > 999999)
SCREWUP("mtime.usec not delimited");
if (!isdigit((unsigned char)*cp))
SCREWUP("atime.sec not present");
ull = strtoull(cp, &cp, 10);
if (!cp || *cp++ != ' ')
SCREWUP("atime.sec not delimited");
if ((time_t)ull < 0 ||
(unsigned long long)(time_t)ull != ull)
setimes = 0; /* out of range */
atime.tv_sec = ull;
atime.tv_usec = strtol(cp, &cp, 10);
if (!cp || *cp++ != '\0' || atime.tv_usec < 0 ||
atime.tv_usec > 999999)
SCREWUP("atime.usec not delimited");
(void) atomicio(vwrite, remout, "", 1);
continue;
}
if (*cp != 'C' && *cp != 'D') {
/*
* Check for the case "rcp remote:foo\* local:bar".
* In this case, the line "No match." can be returned
* by the shell before the rcp command on the remote is
* executed so the ^Aerror_message convention isn't
* followed.
*/
if (first) {
run_err("%s", cp);
exit(1);
}
SCREWUP("expected control record");
}
mode = 0;
for (++cp; cp < buf + 5; cp++) {
if (*cp < '0' || *cp > '7')
SCREWUP("bad mode");
mode = (mode << 3) | (*cp - '0');
}
if (*cp++ != ' ')
SCREWUP("mode not delimited");
for (size = 0; isdigit((unsigned char)*cp);)
size = size * 10 + (*cp++ - '0');
if (*cp++ != ' ')
SCREWUP("size not delimited");
if ((strchr(cp, '/') != NULL) || (strcmp(cp, "..") == 0)) {
run_err("error: unexpected filename: %s", cp);
exit(1);
}
if (targisdir) {
static char *namebuf;
static size_t cursize;
size_t need;
need = strlen(targ) + strlen(cp) + 250;
if (need > cursize) {
free(namebuf);
namebuf = xmalloc(need);
cursize = need;
}
(void) snprintf(namebuf, need, "%s%s%s", targ,
strcmp(targ, "/") ? "/" : "", cp);
np = namebuf;
} else
np = targ;
curfile = cp;
exists = stat(np, &stb) == 0;
if (buf[0] == 'D') {
int mod_flag = pflag;
if (!iamrecursive)
SCREWUP("received directory without -r");
if (exists) {
if (!S_ISDIR(stb.st_mode)) {
errno = ENOTDIR;
goto bad;
}
if (pflag)
(void) chmod(np, mode);
} else {
/* Handle copying from a read-only
directory */
mod_flag = 1;
if (mkdir(np, mode | S_IRWXU) < 0)
goto bad;
}
vect[0] = xstrdup(np);
sink(1, vect);
if (setimes) {
setimes = 0;
if (utimes(vect[0], tv) < 0)
run_err("%s: set times: %s",
vect[0], strerror(errno));
}
if (mod_flag)
(void) chmod(vect[0], mode);
free(vect[0]);
continue;
}
omode = mode;
mode |= S_IWUSR;
if ((ofd = open(np, O_WRONLY|O_CREAT, mode)) < 0) {
bad: run_err("%s: %s", np, strerror(errno));
continue;
}
(void) atomicio(vwrite, remout, "", 1);
if ((bp = allocbuf(&buffer, ofd, COPY_BUFLEN)) == NULL) {
(void) close(ofd);
continue;
}
cp = bp->buf;
wrerr = NO;
statbytes = 0;
if (showprogress)
start_progress_meter(curfile, size, &statbytes);
set_nonblock(remin);
for (count = i = 0; i < size; i += bp->cnt) {
amt = bp->cnt;
if (i + amt > size)
amt = size - i;
count += amt;
do {
j = atomicio6(read, remin, cp, amt,
scpio, &statbytes);
if (j == 0) {
run_err("%s", j != EPIPE ?
strerror(errno) :
"dropped connection");
exit(1);
}
amt -= j;
cp += j;
} while (amt > 0);
if (count == bp->cnt) {
/* Keep reading so we stay sync'd up. */
if (wrerr == NO) {
if (atomicio(vwrite, ofd, bp->buf,
count) != count) {
wrerr = YES;
wrerrno = errno;
}
}
count = 0;
cp = bp->buf;
}
}
unset_nonblock(remin);
if (showprogress)
stop_progress_meter();
if (count != 0 && wrerr == NO &&
atomicio(vwrite, ofd, bp->buf, count) != count) {
wrerr = YES;
wrerrno = errno;
}
if (wrerr == NO && (!exists || S_ISREG(stb.st_mode)) &&
ftruncate(ofd, size) != 0) {
run_err("%s: truncate: %s", np, strerror(errno));
wrerr = DISPLAYED;
}
if (pflag) {
if (exists || omode != mode)
#ifdef HAVE_FCHMOD
if (fchmod(ofd, omode)) {
#else /* HAVE_FCHMOD */
if (chmod(np, omode)) {
#endif /* HAVE_FCHMOD */
run_err("%s: set mode: %s",
np, strerror(errno));
wrerr = DISPLAYED;
}
} else {
if (!exists && omode != mode)
#ifdef HAVE_FCHMOD
if (fchmod(ofd, omode & ~mask)) {
#else /* HAVE_FCHMOD */
if (chmod(np, omode & ~mask)) {
#endif /* HAVE_FCHMOD */
run_err("%s: set mode: %s",
np, strerror(errno));
wrerr = DISPLAYED;
}
}
if (close(ofd) == -1) {
wrerr = YES;
wrerrno = errno;
}
(void) response();
if (setimes && wrerr == NO) {
setimes = 0;
if (utimes(np, tv) < 0) {
run_err("%s: set times: %s",
np, strerror(errno));
wrerr = DISPLAYED;
}
}
switch (wrerr) {
case YES:
run_err("%s: %s", np, strerror(wrerrno));
break;
case NO:
(void) atomicio(vwrite, remout, "", 1);
break;
case DISPLAYED:
break;
}
}
screwup:
run_err("protocol error: %s", why);
exit(1);
}
int
response(void)
{
char ch, *cp, resp, rbuf[2048];
if (atomicio(read, remin, &resp, sizeof(resp)) != sizeof(resp))
lostconn(0);
cp = rbuf;
switch (resp) {
case 0: /* ok */
return (0);
default:
*cp++ = resp;
/* FALLTHROUGH */
case 1: /* error, followed by error msg */
case 2: /* fatal error, "" */
do {
if (atomicio(read, remin, &ch, sizeof(ch)) != sizeof(ch))
lostconn(0);
*cp++ = ch;
} while (cp < &rbuf[sizeof(rbuf) - 1] && ch != '\n');
if (!iamremote)
(void) atomicio(vwrite, STDERR_FILENO, rbuf, cp - rbuf);
++errs;
if (resp == 1)
return (-1);
exit(1);
}
/* NOTREACHED */
}
void
usage(void)
{
(void) fprintf(stderr,
"usage: scp [-12346BCpqrv] [-c cipher] [-F ssh_config] [-i identity_file]\n"
" [-l limit] [-o ssh_option] [-P port] [-S program]\n"
" [[user@]host1:]file1 ... [[user@]host2:]file2\n");
exit(1);
}
void
populate(char *name)
{
char longname[Maxlongname+1];
char *nextname = nil;
long chksum, linkflg, namelen;
vlong blkno;
char *fname;
Fileinf f;
Hdr *hp;
tapefile = open(name, OREAD);
if (tapefile < 0)
error("Can't open argument file");
replete = 1;
hp = &dblock;
for (blkno = 0; ; blkno++) {
seek(tapefile, Tblock*blkno, 0);
if (readn(tapefile, hp->dummy, sizeof hp->dummy) < sizeof hp->dummy)
break;
fname = nextname, nextname = nil;
if(fname == nil || fname[0] == '\0')
fname = tarname(hp);
if (fname[0] == '\0')
break;
/* crack header */
f.addr = blkno + 1;
f.mode = strtoul(hp->mode, 0, 8);
f.uid = strtoul(hp->uid, 0, 8);
f.gid = strtoul(hp->gid, 0, 8);
if((uchar)hp->size[0] == 0x80)
f.size = b8byte(hp->size+3);
else
f.size = strtoull(hp->size, 0, 8);
f.mdate = strtoul(hp->mtime, 0, 8);
chksum = strtoul(hp->chksum, 0, 8);
/* the mode test is ugly but sometimes necessary */
if (hp->linkflag == LF_DIR || (f.mode&0170000) == 040000 ||
strrchr(fname, '\0')[-1] == '/'){
f.mode |= DMDIR;
f.size = 0;
}
f.mode &= DMDIR | 0777;
/* make file name safe, canonical and free of . and .. */
while (fname[0] == '/') /* don't allow absolute paths */
++fname;
cleanname(fname);
while (strncmp(fname, "../", 3) == 0)
fname += 3;
/* reject links */
linkflg = hp->linkflag == LF_SYMLINK1 ||
hp->linkflag == LF_SYMLINK2 || hp->linkflag == LF_LINK;
if (chksum != checksum()){
fprint(2, "%s: bad checksum on %.28s at offset %lld\n",
argv0, fname, Tblock*blkno);
exits("checksum");
}
if (linkflg) {
/*fprint(2, "link %s->%s skipped\n", fname, hp->linkname);*/
f.size = 0;
} else if (hp->linkflag == LF_LONGLINK) {
;
} else if (hp->linkflag == LF_LONGNAME) {
namelen = Maxlongname;
if(f.size < namelen)
namelen = f.size;
namelen = readn(tapefile, longname, namelen);
if(namelen < 0) namelen = 0;
longname[namelen] = '\0';
nextname = longname;
} else {
/* accept this file */
f.name = fname;
if (f.name[0] == '\0')
fprint(2, "%s: null name skipped\n", argv0);
else
poppath(f, 1);
}
blkno += (f.size + Tblock - 1)/Tblock;
}
}
static long
sdwrite(Chan* c, void* a, long n, vlong off)
{
char *f0;
int i, atacdb, proto, ataproto;
uchar *u;
uvlong end, start;
Cmdbuf *cb;
SDifc *ifc;
SDreq *req;
SDunit *unit;
SDev *sdev;
switch(TYPE(c->qid)){
default:
error(Eperm);
case Qtopctl:
cb = parsecmd(a, n);
if(waserror()){
free(cb);
nexterror();
}
if(cb->nf == 0)
error("empty control message");
f0 = cb->f[0];
cb->f++;
cb->nf--;
if(strcmp(f0, "config") == 0){
/* wormhole into ugly legacy interface */
legacytopctl(cb);
poperror();
free(cb);
break;
}
/*
* "ata arg..." invokes sdifc[i]->wtopctl(nil, cb),
* where sdifc[i]->name=="ata" and cb contains the args.
*/
ifc = nil;
sdev = nil;
for(i=0; sdifc[i]; i++){
if(strcmp(sdifc[i]->name, f0) == 0){
ifc = sdifc[i];
sdev = nil;
goto subtopctl;
}
}
/*
* "sd1 arg..." invokes sdifc[i]->wtopctl(sdev, cb),
* where sdifc[i] and sdev match controller letter "1",
* and cb contains the args.
*/
if(f0[0]=='s' && f0[1]=='d' && f0[2] && f0[3] == 0){
if((sdev = sdgetdev(f0[2])) != nil){
ifc = sdev->ifc;
goto subtopctl;
}
}
error("unknown interface");
subtopctl:
if(waserror()){
if(sdev)
decref(&sdev->r);
nexterror();
}
if(ifc->wtopctl)
ifc->wtopctl(sdev, cb);
else
error(Ebadctl);
poperror();
poperror();
if(sdev)
decref(&sdev->r);
free(cb);
break;
case Qctl:
cb = parsecmd(a, n);
sdev = sdgetdev(DEV(c->qid));
if(sdev == nil)
error(Enonexist);
unit = sdev->unit[UNIT(c->qid)];
qlock(&unit->ctl);
if(waserror()){
qunlock(&unit->ctl);
decref(&sdev->r);
free(cb);
nexterror();
}
if(unit->vers != c->qid.vers)
error(Echange);
if(cb->nf < 1)
error(Ebadctl);
if(strcmp(cb->f[0], "part") == 0){
if(cb->nf != 4)
error(Ebadctl);
if(unit->sectors == 0 && !sdinitpart(unit))
error(Eio);
start = strtoull(cb->f[2], 0, 0);
end = strtoull(cb->f[3], 0, 0);
sdaddpart(unit, cb->f[1], start, end);
}
else if(strcmp(cb->f[0], "delpart") == 0){
if(cb->nf != 2 || unit->part == nil)
error(Ebadctl);
sddelpart(unit, cb->f[1]);
}
else if(unit->dev->ifc->wctl)
unit->dev->ifc->wctl(unit, cb);
else
error(Ebadctl);
qunlock(&unit->ctl);
decref(&sdev->r);
poperror();
free(cb);
break;
case Qraw:
proto = SDcdb;
ataproto = 0;
atacdb = 0;
sdev = sdgetdev(DEV(c->qid));
if(sdev == nil)
error(Enonexist);
unit = sdev->unit[UNIT(c->qid)];
qlock(&unit->raw);
if(waserror()){
qunlock(&unit->raw);
decref(&sdev->r);
nexterror();
}
switch(unit->state){
case Rawcmd:
/* sneaky ata commands */
u = a;
if(n > 1 && *u == 0xff){
proto = SData;
ataproto = u[1];
a = u + 2;
atacdb = Ahdrsz;
n -= Ahdrsz;
}
if(n < 6 || n > sizeof(req->cmd))
error(Ebadarg);
req = smalloc(sizeof(SDreq));
req->unit = unit;
if(waserror()){
free(req);
nexterror();
}
memmove(req->cmd, a, n);
poperror();
req->clen = n;
/* req->flags = SDnosense; */
req->status = ~0;
req->proto = proto;
req->ataproto = ataproto;
unit->req = req;
unit->state = Rawdata;
n += atacdb;
break;
case Rawstatus:
unit->state = Rawcmd;
free(unit->req);
unit->req = nil;
error(Ebadusefd);
case Rawdata:
unit->state = Rawstatus;
req = unit->req;
req->write = 1;
n = sdrio(req, a, n);
}
poperror();
qunlock(&unit->raw);
decref(&sdev->r);
break;
case Qpart:
return sdbio(c, 1, a, n, off);
case Qextra:
return extrarw(1, c, a, n, off);
}
return n;
}
int main( int argc, char** argv ) {
int rc = 0;
struct md_opts opts;
int new_optind = 0;
uint64_t remote_gateway_id = 0;
uint64_t volume_id = 0;
uint64_t file_id = 0x1234567890ABCDEF;
int64_t file_version = 1234567890;
struct timespec ts;
uint64_t block_id = 0;
int64_t block_version = 0;
unsigned char fake_hash[32];
clock_gettime( CLOCK_REALTIME, &ts );
// make it every 20 seconds, to test caching
ts.tv_sec = (ts.tv_sec / 20) * 20;
ts.tv_nsec = 0;
struct ms_client* ms = NULL;
struct SG_manifest write_delta;
SG_messages::Request request;
SG_messages::Reply reply;
char* tmp = NULL;
char* gateway_id_str = NULL;
char* fs_path = NULL;
// read opts, and find the end of the syndicate options
rc = common_parse_opts( &opts, argc, argv, &new_optind );
if( rc != 0 ) {
usage( argv[0] );
}
md_opts_free( &opts );
// must have an even number of remaining options, beyond the file path and gateway id
if( (argc - new_optind) % 2 != 0 || new_optind + 2 >= argc ) {
printf("new_optind = %d, argc = %d\n", new_optind, argc );
usage( argv[0] );
}
gateway_id_str = argv[new_optind];
fs_path = argv[new_optind+1];
remote_gateway_id = strtoull( gateway_id_str, &tmp, 10 );
if( *tmp != '\0' ) {
usage( argv[0] );
}
// us
struct SG_gateway gateway;
memset( &gateway, 0, sizeof(struct SG_gateway) );
// start up
rc = SG_gateway_init( &gateway, SYNDICATE_UG, false, argc, argv );
if( rc != 0 ) {
SG_error("SG_gateway_init rc = %d\n", rc );
exit(1);
}
SG_info("%s", "Initialized\n");
ms = SG_gateway_ms( &gateway );
volume_id = ms_client_get_volume_id( ms );
// create write request
rc = SG_manifest_init( &write_delta, volume_id, remote_gateway_id, file_id, file_version );
if( rc != 0 ) {
SG_error("SG_manifst_init( write_delta ) rc = %d\n", rc );
exit(2);
}
// give it a modtime of mod-20 seconds
SG_manifest_set_modtime( &write_delta, ts.tv_sec, ts.tv_nsec );
// coordinator is the remote gateway
SG_manifest_set_coordinator_id( &write_delta, remote_gateway_id );
// fake hash...
for( int i = 0; i < 32; i++ ) {
fake_hash[i] = i;
}
// populate from argv
for( int i = new_optind + 2; i < argc; i += 2 ) {
block_id = strtoull( argv[i], &tmp, 10 );
if( *tmp != '\0' ) {
SG_error("Failed to parse block ID '%s'\n", argv[i] );
usage( argv[0] );
}
block_version = strtoll( argv[i+1], &tmp, 10 );
if( *tmp != '\0' ) {
SG_error("Failed to parse block version '%s'\n", argv[i] );
usage( argv[0] );
}
// make a block
struct SG_manifest_block block;
rc = SG_manifest_block_init( &block, block_id, block_version, fake_hash, 32 );
if( rc != 0 ) {
SG_error("SG_manifest_block_init rc = %d\n", rc );
exit(2);
}
// put this write
rc = SG_manifest_put_block( &write_delta, &block, true );
if( rc != 0 ) {
SG_error("SG_manifest_put_block rc = %d\n", rc );
exit(2);
}
SG_manifest_block_free( &block );
}
// generate the request
rc = SG_client_request_WRITE_setup( &gateway, &request, fs_path, &write_delta );
if( rc != 0 ) {
SG_error("SG_client_request_WRITE_setup rc = %d\n", rc );
exit(2);
}
common_print_request( &request );
// send it off
rc = SG_client_request_send( &gateway, remote_gateway_id, &request, NULL, &reply );
if( rc != 0 ) {
SG_error("SG_client_request_send rc = %d\n", rc );
exit(2);
}
// got a reply!
// print it out
printf("\n");
common_print_reply( &reply );
SG_gateway_shutdown( &gateway );
return 0;
}
struct mdinfo *sysfs_read(int fd, char *devnm, unsigned long options)
{
char fname[PATH_MAX];
char buf[PATH_MAX];
char *base;
char *dbase;
struct mdinfo *sra;
struct mdinfo *dev, **devp;
DIR *dir = NULL;
struct dirent *de;
sra = xcalloc(1, sizeof(*sra));
sysfs_init(sra, fd, devnm);
if (sra->sys_name[0] == 0) {
free(sra);
return NULL;
}
sprintf(fname, "/sys/block/%s/md/", sra->sys_name);
base = fname + strlen(fname);
sra->devs = NULL;
if (options & GET_VERSION) {
strcpy(base, "metadata_version");
if (load_sys(fname, buf))
goto abort;
if (strncmp(buf, "none", 4) == 0) {
sra->array.major_version =
sra->array.minor_version = -1;
strcpy(sra->text_version, "");
} else if (strncmp(buf, "external:", 9) == 0) {
sra->array.major_version = -1;
sra->array.minor_version = -2;
strcpy(sra->text_version, buf+9);
} else {
sscanf(buf, "%d.%d",
&sra->array.major_version,
&sra->array.minor_version);
strcpy(sra->text_version, buf);
}
}
if (options & GET_LEVEL) {
strcpy(base, "level");
if (load_sys(fname, buf))
goto abort;
sra->array.level = map_name(pers, buf);
}
if (options & GET_LAYOUT) {
strcpy(base, "layout");
if (load_sys(fname, buf))
goto abort;
sra->array.layout = strtoul(buf, NULL, 0);
}
if (options & GET_DISKS) {
strcpy(base, "raid_disks");
if (load_sys(fname, buf))
goto abort;
sra->array.raid_disks = strtoul(buf, NULL, 0);
}
if (options & GET_DEGRADED) {
strcpy(base, "degraded");
if (load_sys(fname, buf))
goto abort;
sra->array.failed_disks = strtoul(buf, NULL, 0);
}
if (options & GET_COMPONENT) {
strcpy(base, "component_size");
if (load_sys(fname, buf))
goto abort;
sra->component_size = strtoull(buf, NULL, 0);
/* sysfs reports "K", but we want sectors */
sra->component_size *= 2;
}
if (options & GET_CHUNK) {
strcpy(base, "chunk_size");
if (load_sys(fname, buf))
goto abort;
sra->array.chunk_size = strtoul(buf, NULL, 0);
}
if (options & GET_CACHE) {
strcpy(base, "stripe_cache_size");
if (load_sys(fname, buf))
/* Probably level doesn't support it */
sra->cache_size = 0;
else
sra->cache_size = strtoul(buf, NULL, 0);
}
if (options & GET_MISMATCH) {
strcpy(base, "mismatch_cnt");
if (load_sys(fname, buf))
goto abort;
sra->mismatch_cnt = strtoul(buf, NULL, 0);
}
if (options & GET_SAFEMODE) {
int scale = 1;
int dot = 0;
unsigned i;
unsigned long msec;
size_t len;
strcpy(base, "safe_mode_delay");
if (load_sys(fname, buf))
goto abort;
/* remove a period, and count digits after it */
len = strlen(buf);
for (i = 0; i < len; i++) {
if (dot) {
if (isdigit(buf[i])) {
buf[i-1] = buf[i];
scale *= 10;
}
buf[i] = 0;
} else if (buf[i] == '.') {
dot=1;
buf[i] = 0;
}
}
msec = strtoul(buf, NULL, 10);
msec = (msec * 1000) / scale;
sra->safe_mode_delay = msec;
}
if (options & GET_BITMAP_LOCATION) {
strcpy(base, "bitmap/location");
if (load_sys(fname, buf))
goto abort;
if (strncmp(buf, "file", 4) == 0)
sra->bitmap_offset = 1;
else if (strncmp(buf, "none", 4) == 0)
sra->bitmap_offset = 0;
else if (buf[0] == '+')
sra->bitmap_offset = strtol(buf+1, NULL, 10);
else
goto abort;
}
if (! (options & GET_DEVS))
return sra;
/* Get all the devices as well */
*base = 0;
dir = opendir(fname);
if (!dir)
goto abort;
sra->array.spare_disks = 0;
devp = &sra->devs;
sra->devs = NULL;
while ((de = readdir(dir)) != NULL) {
char *ep;
if (de->d_ino == 0 ||
strncmp(de->d_name, "dev-", 4) != 0)
continue;
strcpy(base, de->d_name);
dbase = base + strlen(base);
*dbase++ = '/';
dev = xmalloc(sizeof(*dev));
/* Always get slot, major, minor */
strcpy(dbase, "slot");
if (load_sys(fname, buf)) {
/* hmm... unable to read 'slot' maybe the device
* is going away?
*/
strcpy(dbase, "block");
if (readlink(fname, buf, sizeof(buf)) < 0 &&
errno != ENAMETOOLONG) {
/* ...yup device is gone */
free(dev);
continue;
} else {
/* slot is unreadable but 'block' link
* still intact... something bad is happening
* so abort
*/
free(dev);
goto abort;
}
}
strcpy(dev->sys_name, de->d_name);
dev->disk.raid_disk = strtoul(buf, &ep, 10);
if (*ep) dev->disk.raid_disk = -1;
strcpy(dbase, "block/dev");
if (load_sys(fname, buf)) {
/* assume this is a stale reference to a hot
* removed device
*/
free(dev);
continue;
}
sra->array.nr_disks++;
sscanf(buf, "%d:%d", &dev->disk.major, &dev->disk.minor);
/* special case check for block devices that can go 'offline' */
strcpy(dbase, "block/device/state");
if (load_sys(fname, buf) == 0 &&
strncmp(buf, "offline", 7) == 0) {
free(dev);
continue;
}
/* finally add this disk to the array */
*devp = dev;
devp = & dev->next;
dev->next = NULL;
if (options & GET_OFFSET) {
strcpy(dbase, "offset");
if (load_sys(fname, buf))
goto abort;
dev->data_offset = strtoull(buf, NULL, 0);
strcpy(dbase, "new_offset");
if (load_sys(fname, buf) == 0)
dev->new_data_offset = strtoull(buf, NULL, 0);
else
dev->new_data_offset = dev->data_offset;
}
if (options & GET_SIZE) {
strcpy(dbase, "size");
if (load_sys(fname, buf))
goto abort;
dev->component_size = strtoull(buf, NULL, 0) * 2;
}
if (options & GET_STATE) {
dev->disk.state = 0;
strcpy(dbase, "state");
if (load_sys(fname, buf))
goto abort;
if (strstr(buf, "in_sync"))
dev->disk.state |= (1<<MD_DISK_SYNC);
if (strstr(buf, "faulty"))
dev->disk.state |= (1<<MD_DISK_FAULTY);
if (dev->disk.state == 0)
sra->array.spare_disks++;
}
if (options & GET_ERROR) {
strcpy(buf, "errors");
if (load_sys(fname, buf))
goto abort;
dev->errors = strtoul(buf, NULL, 0);
}
}
closedir(dir);
return sra;
abort:
if (dir)
closedir(dir);
sysfs_free(sra);
return NULL;
}
static void
process_limit (const pam_handle_t *pamh, int source, const char *lim_type,
const char *lim_item, const char *lim_value,
int ctrl, struct pam_limit_s *pl)
{
int limit_item;
int limit_type = 0;
int int_value = 0;
rlim_t rlimit_value = 0;
char *endptr;
const char *value_orig = lim_value;
if (ctrl & PAM_DEBUG_ARG)
pam_syslog(pamh, LOG_DEBUG, "%s: processing %s %s %s for %s",
__FUNCTION__, lim_type, lim_item, lim_value,
limits_def_names[source]);
if (strcmp(lim_item, "cpu") == 0)
limit_item = RLIMIT_CPU;
else if (strcmp(lim_item, "fsize") == 0)
limit_item = RLIMIT_FSIZE;
else if (strcmp(lim_item, "data") == 0)
limit_item = RLIMIT_DATA;
else if (strcmp(lim_item, "stack") == 0)
limit_item = RLIMIT_STACK;
else if (strcmp(lim_item, "core") == 0)
limit_item = RLIMIT_CORE;
else if (strcmp(lim_item, "rss") == 0)
limit_item = RLIMIT_RSS;
else if (strcmp(lim_item, "nproc") == 0)
limit_item = RLIMIT_NPROC;
else if (strcmp(lim_item, "nofile") == 0)
limit_item = RLIMIT_NOFILE;
else if (strcmp(lim_item, "memlock") == 0)
limit_item = RLIMIT_MEMLOCK;
else if (strcmp(lim_item, "as") == 0)
limit_item = RLIMIT_AS;
#ifdef RLIMIT_LOCKS
else if (strcmp(lim_item, "locks") == 0)
limit_item = RLIMIT_LOCKS;
#endif
#ifdef RLIMIT_SIGPENDING
else if (strcmp(lim_item, "sigpending") == 0)
limit_item = RLIMIT_SIGPENDING;
#endif
#ifdef RLIMIT_MSGQUEUE
else if (strcmp(lim_item, "msgqueue") == 0)
limit_item = RLIMIT_MSGQUEUE;
#endif
#ifdef RLIMIT_NICE
else if (strcmp(lim_item, "nice") == 0)
limit_item = RLIMIT_NICE;
#endif
#ifdef RLIMIT_RTPRIO
else if (strcmp(lim_item, "rtprio") == 0)
limit_item = RLIMIT_RTPRIO;
#endif
else if (strcmp(lim_item, "maxlogins") == 0) {
limit_item = LIMIT_LOGIN;
pl->flag_numsyslogins = 0;
} else if (strcmp(lim_item, "maxsyslogins") == 0) {
limit_item = LIMIT_NUMSYSLOGINS;
pl->flag_numsyslogins = 1;
} else if (strcmp(lim_item, "priority") == 0) {
limit_item = LIMIT_PRI;
} else {
pam_syslog(pamh, LOG_DEBUG, "unknown limit item '%s'", lim_item);
return;
}
if (strcmp(lim_type,"soft")==0)
limit_type=LIMIT_SOFT;
else if (strcmp(lim_type, "hard")==0)
limit_type=LIMIT_HARD;
else if (strcmp(lim_type,"-")==0)
limit_type=LIMIT_SOFT | LIMIT_HARD;
else if (limit_item != LIMIT_LOGIN && limit_item != LIMIT_NUMSYSLOGINS) {
pam_syslog(pamh, LOG_DEBUG, "unknown limit type '%s'", lim_type);
return;
}
if (limit_item != LIMIT_PRI
#ifdef RLIMIT_NICE
&& limit_item != RLIMIT_NICE
#endif
&& (strcmp(lim_value, "-1") == 0
|| strcmp(lim_value, "-") == 0 || strcmp(lim_value, "unlimited") == 0
|| strcmp(lim_value, "infinity") == 0)) {
int_value = -1;
rlimit_value = RLIM_INFINITY;
} else if (limit_item == LIMIT_PRI || limit_item == LIMIT_LOGIN ||
#ifdef RLIMIT_NICE
limit_item == RLIMIT_NICE ||
#endif
limit_item == LIMIT_NUMSYSLOGINS) {
long temp;
temp = strtol (lim_value, &endptr, 10);
temp = temp < INT_MAX ? temp : INT_MAX;
int_value = temp > INT_MIN ? temp : INT_MIN;
if (int_value == 0 && value_orig == endptr) {
pam_syslog(pamh, LOG_DEBUG,
"wrong limit value '%s' for limit type '%s'",
lim_value, lim_type);
return;
}
} else {
#ifdef __USE_FILE_OFFSET64
rlimit_value = strtoull (lim_value, &endptr, 10);
#else
rlimit_value = strtoul (lim_value, &endptr, 10);
#endif
if (rlimit_value == 0 && value_orig == endptr) {
pam_syslog(pamh, LOG_DEBUG,
"wrong limit value '%s' for limit type '%s'",
lim_value, lim_type);
return;
}
}
/* one more special case when limiting logins */
if ((source == LIMITS_DEF_ALL || source == LIMITS_DEF_ALLGROUP)
&& (limit_item != LIMIT_LOGIN)) {
if (ctrl & PAM_DEBUG_ARG)
pam_syslog(pamh, LOG_DEBUG,
"'%%' domain valid for maxlogins type only");
return;
}
switch(limit_item) {
case RLIMIT_CPU:
if (rlimit_value != RLIM_INFINITY)
rlimit_value *= 60;
break;
case RLIMIT_FSIZE:
case RLIMIT_DATA:
case RLIMIT_STACK:
case RLIMIT_CORE:
case RLIMIT_RSS:
case RLIMIT_MEMLOCK:
case RLIMIT_AS:
if (rlimit_value != RLIM_INFINITY)
rlimit_value *= 1024;
break;
#ifdef RLIMIT_NICE
case RLIMIT_NICE:
if (int_value > 19)
int_value = 19;
rlimit_value = 19 - int_value;
#endif
break;
}
if ( (limit_item != LIMIT_LOGIN)
&& (limit_item != LIMIT_NUMSYSLOGINS)
&& (limit_item != LIMIT_PRI) ) {
if (limit_type & LIMIT_SOFT) {
if (pl->limits[limit_item].src_soft < source) {
return;
} else {
pl->limits[limit_item].limit.rlim_cur = rlimit_value;
pl->limits[limit_item].src_soft = source;
}
}
if (limit_type & LIMIT_HARD) {
if (pl->limits[limit_item].src_hard < source) {
return;
} else {
pl->limits[limit_item].limit.rlim_max = rlimit_value;
pl->limits[limit_item].src_hard = source;
}
}
} else {
/* recent kernels support negative priority limits (=raise priority) */
if (limit_item == LIMIT_PRI) {
pl->priority = int_value;
} else {
if (pl->login_limit_def < source) {
return;
} else {
pl->login_limit = int_value;
pl->login_limit_def = source;
}
}
}
return;
}
/* Parse the data section of VCD */
static void parse_contents(FILE *file, const struct sr_dev_inst *sdi, struct context *ctx)
{
GString *token = g_string_sized_new(32);
uint64_t prev_timestamp = 0;
uint64_t prev_values = 0;
/* Read one space-delimited token at a time. */
while (read_until(file, NULL, 'N') && read_until(file, token, 'W'))
{
if (token->str[0] == '#' && g_ascii_isdigit(token->str[1]))
{
/* Numeric value beginning with # is a new timestamp value */
uint64_t timestamp;
timestamp = strtoull(token->str + 1, NULL, 10);
if (ctx->downsample > 1)
timestamp /= ctx->downsample;
/* Skip < 0 => skip until first timestamp.
* Skip = 0 => don't skip
* Skip > 0 => skip until timestamp >= skip.
*/
if (ctx->skip < 0)
{
ctx->skip = timestamp;
prev_timestamp = timestamp;
}
else if (ctx->skip > 0 && timestamp < (uint64_t)ctx->skip)
{
prev_timestamp = ctx->skip;
}
else if (timestamp == prev_timestamp)
{
/* Ignore repeated timestamps (e.g. sigrok outputs these) */
}
else
{
if (ctx->compress != 0 && timestamp - prev_timestamp > ctx->compress)
{
/* Compress long idle periods */
prev_timestamp = timestamp - ctx->compress;
}
sr_dbg("New timestamp: %" PRIu64, timestamp);
/* Generate samples from prev_timestamp up to timestamp - 1. */
send_samples(sdi, prev_values, timestamp - prev_timestamp);
prev_timestamp = timestamp;
}
}
else if (token->str[0] == '$' && token->len > 1)
{
/* This is probably a $dumpvars, $comment or similar.
* $dump* contain useful data, but other tags will be skipped until $end. */
if (g_strcmp0(token->str, "$dumpvars") == 0 ||
g_strcmp0(token->str, "$dumpon") == 0 ||
g_strcmp0(token->str, "$dumpoff") == 0 ||
g_strcmp0(token->str, "$end") == 0)
{
/* Ignore, parse contents as normally. */
}
else
{
/* Skip until $end */
read_until(file, NULL, '$');
}
}
else if (strchr("bBrR", token->str[0]) != NULL)
{
/* A vector value. Skip it and also the following identifier. */
read_until(file, NULL, 'N');
read_until(file, NULL, 'W');
}
else if (strchr("01xXzZ", token->str[0]) != NULL)
{
/* A new 1-bit sample value */
int i, bit;
GSList *l;
struct probe *probe;
bit = (token->str[0] == '1');
g_string_erase(token, 0, 1);
if (token->len == 0)
{
/* There was a space between value and identifier.
* Read in the rest.
*/
read_until(file, NULL, 'N');
read_until(file, token, 'W');
}
for (i = 0, l = ctx->probes; i < ctx->probecount && l; i++, l = l->next)
{
probe = l->data;
if (g_strcmp0(token->str, probe->identifier) == 0)
{
sr_dbg("Probe %d new value %d.", i, bit);
/* Found our probe */
if (bit)
prev_values |= (1 << i);
else
prev_values &= ~(1 << i);
break;
}
}
if (i == ctx->probecount)
{
sr_dbg("Did not find probe for identifier '%s'.", token->str);
}
}
else
{
sr_warn("Skipping unknown token '%s'.", token->str);
}
g_string_truncate(token, 0);
}
g_string_free(token, TRUE);
}
int main(int argc, char* argv[]) {
int i = 0;
int opt = 0;
int action = 0;
unsigned long long ecid = 0;
int mode = -1;
char* argument = NULL;
irecv_error_t error = 0;
char* buffer = NULL;
uint64_t buffer_length = 0;
if (argc == 1) {
print_usage(argc, argv);
return 0;
}
while ((opt = getopt(argc, argv, "i:vhrsmnc:f:e:k::")) > 0) {
switch (opt) {
case 'i':
if (optarg) {
char* tail = NULL;
ecid = strtoull(optarg, &tail, 16);
if (tail && (tail[0] != '\0')) {
ecid = 0;
}
if (ecid == 0) {
fprintf(stderr, "ERROR: Could not parse ECID from argument '%s'\n", optarg);
return -1;
}
}
break;
case 'v':
verbose += 1;
break;
case 'h':
print_usage(argc, argv);
return 0;
case 'm':
action = kShowMode;
break;
case 'n':
action = kRebootToNormalMode;
break;
case 'r':
action = kResetDevice;
break;
case 's':
action = kStartShell;
break;
case 'f':
action = kSendFile;
argument = optarg;
break;
case 'c':
action = kSendCommand;
argument = optarg;
break;
case 'k':
action = kSendExploit;
argument = optarg;
break;
case 'e':
action = kSendScript;
argument = optarg;
break;
default:
fprintf(stderr, "Unknown argument\n");
return -1;
}
}
if (verbose)
irecv_set_debug_level(verbose);
irecv_init();
irecv_client_t client = NULL;
for (i = 0; i <= 5; i++) {
debug("Attempting to connect... \n");
if (irecv_open_with_ecid(&client, ecid) != IRECV_E_SUCCESS)
sleep(1);
else
break;
if (i == 5) {
return -1;
}
}
irecv_device_t device = NULL;
irecv_devices_get_device_by_client(client, &device);
if (device)
debug("Connected to %s, model %s, cpid 0x%04x, bdid 0x%02x\n", device->product_type, device->hardware_model, device->chip_id, device->board_id);
switch (action) {
case kResetDevice:
irecv_reset(client);
break;
case kSendFile:
irecv_event_subscribe(client, IRECV_PROGRESS, &progress_cb, NULL);
error = irecv_send_file(client, argument, 1);
debug("%s\n", irecv_strerror(error));
break;
case kSendCommand:
error = irecv_send_command(client, argument);
debug("%s\n", irecv_strerror(error));
break;
case kSendExploit:
if (argument != NULL) {
irecv_event_subscribe(client, IRECV_PROGRESS, &progress_cb, NULL);
error = irecv_send_file(client, argument, 0);
if (error != IRECV_E_SUCCESS) {
debug("%s\n", irecv_strerror(error));
break;
}
}
error = irecv_trigger_limera1n_exploit(client);
debug("%s\n", irecv_strerror(error));
break;
case kStartShell:
init_shell(client);
break;
case kSendScript:
buffer_read_from_filename(argument, &buffer, &buffer_length);
if (buffer) {
buffer[buffer_length] = '\0';
error = irecv_execute_script(client, buffer);
if(error != IRECV_E_SUCCESS) {
debug("%s\n", irecv_strerror(error));
}
free(buffer);
} else {
fprintf(stderr, "Could not read file '%s'\n", argument);
}
break;
case kShowMode:
irecv_get_mode(client, &mode);
printf("%s Mode\n", mode_to_str(mode));
break;
case kRebootToNormalMode:
error = irecv_setenv(client, "auto-boot", "true");
if (error != IRECV_E_SUCCESS) {
debug("%s\n", irecv_strerror(error));
break;
}
error = irecv_saveenv(client);
if (error != IRECV_E_SUCCESS) {
debug("%s\n", irecv_strerror(error));
break;
}
error = irecv_reboot(client);
if (error != IRECV_E_SUCCESS) {
debug("%s\n", irecv_strerror(error));
} else {
debug("%s\n", irecv_strerror(error));
}
break;
default:
fprintf(stderr, "Unknown action\n");
break;
}
irecv_close(client);
return 0;
}
acl_int64 acl_atoi64(const char *str)
{
return ((acl_int64) strtoull(str, NULL, 10));
}
/**
* parse a value into a suitable metadata or sysmd
*
* @param key
* @param val
* @param metadatum_func
* @param cb_arg
* @param metadata
* @param sysmdp
*
* @return
*/
dpl_status_t
dpl_cdmi_get_metadatum_from_value(const char *key,
dpl_value_t *val,
dpl_metadatum_func_t metadatum_func,
void *cb_arg,
dpl_dict_t *metadata,
dpl_sysmd_t *sysmdp)
{
dpl_status_t ret, ret2;
dpl_dict_var_t *var;
dpl_cdmi_object_id_t obj_id;
DPRINTF("key=%s val.type=%d\n", key, val->type);
if (sysmdp)
{
if (!strcmp(key, "objectID"))
{
if (DPL_VALUE_STRING != val->type)
{
ret = DPL_EINVAL;
goto end;
}
ret2 = dpl_cdmi_string_to_object_id(dpl_sbuf_get_str(val->string),
&obj_id);
if (DPL_SUCCESS != ret2)
{
ret = ret2;
goto end;
}
ret2 = dpl_cdmi_opaque_to_string(&obj_id, sysmdp->id);
if (DPL_SUCCESS != ret2)
{
ret = ret2;
goto end;
}
sysmdp->mask |= DPL_SYSMD_MASK_ID;
sysmdp->enterprise_number = obj_id.enterprise_number;
sysmdp->mask |= DPL_SYSMD_MASK_ENTERPRISE_NUMBER;
}
else if (!strcmp(key, "parentID"))
{
if (DPL_VALUE_STRING != val->type)
{
ret = DPL_EINVAL;
goto end;
}
if (strcmp(dpl_sbuf_get_str(val->string), ""))
{
ret2 = dpl_cdmi_string_to_object_id(dpl_sbuf_get_str(val->string), &obj_id);
if (DPL_SUCCESS != ret2)
{
ret = ret2;
goto end;
}
ret2 = dpl_cdmi_opaque_to_string(&obj_id, sysmdp->parent_id);
if (DPL_SUCCESS != ret2)
{
ret = ret2;
goto end;
}
sysmdp->mask |= DPL_SYSMD_MASK_PARENT_ID;
}
}
else if (!strcmp(key, "objectType"))
{
if (DPL_VALUE_STRING != val->type)
{
ret = DPL_EINVAL;
goto end;
}
sysmdp->mask |= DPL_SYSMD_MASK_FTYPE;
sysmdp->ftype = dpl_cdmi_content_type_to_ftype(dpl_sbuf_get_str(val->string));
}
}
if (!strcmp(key, "metadata"))
{
//this is the metadata object
if (DPL_VALUE_SUBDICT != val->type)
{
ret = DPL_EINVAL;
goto end;
}
if (sysmdp)
{
//some sysmds are stored in metadata
var = dpl_dict_get(val->subdict, "cdmi_mtime");
if (NULL != var)
{
if (DPL_VALUE_STRING != var->val->type)
{
ret = DPL_EINVAL;
goto end;
}
sysmdp->mask |= DPL_SYSMD_MASK_MTIME;
sysmdp->mtime = dpl_iso8601totime(dpl_sbuf_get_str(var->val->string));
}
var = dpl_dict_get(val->subdict, "cdmi_atime");
if (NULL != var)
{
if (DPL_VALUE_STRING != var->val->type)
{
ret = DPL_EINVAL;
goto end;
}
sysmdp->mask |= DPL_SYSMD_MASK_ATIME;
sysmdp->atime = dpl_iso8601totime(dpl_sbuf_get_str(var->val->string));
}
var = dpl_dict_get(val->subdict, "cdmi_size");
if (NULL != var)
{
if (DPL_VALUE_STRING != var->val->type)
{
ret = DPL_EINVAL;
goto end;
}
sysmdp->mask |= DPL_SYSMD_MASK_SIZE;
sysmdp->size = strtoull(dpl_sbuf_get_str(var->val->string), NULL, 0);
}
}
if (metadata)
{
struct metadata_list_arg arg;
arg.metadatum_func = metadatum_func;
arg.metadata = metadata;
arg.cb_arg = cb_arg;
//iterate metadata object
ret2 = dpl_dict_iterate(val->subdict, cb_metadata_list, &arg);
if (DPL_SUCCESS != ret2)
{
ret = ret2;
goto end;
}
}
}
ret = DPL_SUCCESS;
end:
return ret;
}
// Converts the default value in string "str" into "d". Passes a ref on str.
// Returns true on success.
static bool parse_default(char *str, upb_value *d, int type) {
bool success = true;
if (str) {
switch(type) {
case UPB_TYPE(INT32):
case UPB_TYPE(SINT32):
case UPB_TYPE(SFIXED32): upb_value_setint32(d, 0); break;
case UPB_TYPE(INT64):
case UPB_TYPE(SINT64):
case UPB_TYPE(SFIXED64): upb_value_setint64(d, 0); break;
case UPB_TYPE(UINT32):
case UPB_TYPE(FIXED32): upb_value_setuint32(d, 0);
case UPB_TYPE(UINT64):
case UPB_TYPE(FIXED64): upb_value_setuint64(d, 0); break;
case UPB_TYPE(DOUBLE): upb_value_setdouble(d, 0); break;
case UPB_TYPE(FLOAT): upb_value_setfloat(d, 0); break;
case UPB_TYPE(BOOL): upb_value_setbool(d, false); break;
default: abort();
}
} else {
char *end;
switch (type) {
case UPB_TYPE(INT32):
case UPB_TYPE(SINT32):
case UPB_TYPE(SFIXED32): {
long val = strtol(str, &end, 0);
if (val > INT32_MAX || val < INT32_MIN || errno == ERANGE || *end)
success = false;
else
upb_value_setint32(d, val);
break;
}
case UPB_TYPE(INT64):
case UPB_TYPE(SINT64):
case UPB_TYPE(SFIXED64):
upb_value_setint64(d, strtoll(str, &end, 0));
if (errno == ERANGE || *end) success = false;
break;
case UPB_TYPE(UINT32):
case UPB_TYPE(FIXED32): {
unsigned long val = strtoul(str, &end, 0);
if (val > UINT32_MAX || errno == ERANGE || *end)
success = false;
else
upb_value_setuint32(d, val);
break;
}
case UPB_TYPE(UINT64):
case UPB_TYPE(FIXED64):
upb_value_setuint64(d, strtoull(str, &end, 0));
if (errno == ERANGE || *end) success = false;
break;
case UPB_TYPE(DOUBLE):
upb_value_setdouble(d, strtod(str, &end));
if (errno == ERANGE || *end) success = false;
break;
case UPB_TYPE(FLOAT):
upb_value_setfloat(d, strtof(str, &end));
if (errno == ERANGE || *end) success = false;
break;
case UPB_TYPE(BOOL): {
if (strcmp(str, "false") == 0)
upb_value_setbool(d, false);
else if (strcmp(str, "true") == 0)
upb_value_setbool(d, true);
else
success = false;
}
default: abort();
}
}
return success;
}
static int vm_create(int argc, char* argv[]) {
// Default value
VMSpec vm = {};
vm.core_size = 1;
vm.memory_size = 0x1000000; // 16MB
vm.storage_size = 0x1000000; // 16MB
// Main options
static struct option options[] = {
{ "core", required_argument, 0, 'c' },
{ "memory", required_argument, 0, 'm' },
{ "storage", required_argument, 0, 's' },
{ "nic", optional_argument, 0, 'n' },
{ "args", required_argument, 0, 'a' },
{ 0, 0, 0, 0 }
};
int opt;
int index = 0;
while((opt = getopt_long(argc, argv, "c:m:s:n::a:", options, &index)) != -1) {
switch(opt) {
case 'c' :
if(!is_uint32(optarg)) goto failure;
vm.core_size = strtol(optarg, NULL, 0);
break;
case 'm' :
if(!is_uint32(optarg)) goto failure;
vm.memory_size = strtol(optarg, NULL, 16);
break;
case 's' :
if(!is_uint32(optarg)) goto failure;
vm.storage_size = strtol(optarg, NULL, 16);
break;
case 'n' :;
// Suboptions for NIC
enum {
EMPTY, MAC, DEV, IBUF, OBUF, IBAND, OBAND, HPAD, TPAD, POOL,
INHERITMAC, NOARP, PROMISC, BROADCAST, MULTICAST, MULTIQUEUE,
};
const char* token[] = {
[EMPTY] = "",
[MAC] = "mac",
[DEV] = "dev",
[IBUF] = "ibuf",
[OBUF] = "obuf",
[IBAND] = "iband",
[OBAND] = "oband",
[HPAD] = "hpad",
[TPAD] = "tpad",
[POOL] = "pool",
[INHERITMAC] = "inheritmac",
[NOARP] = "noarp",
[PROMISC] = "promisc",
[BROADCAST] = "broadcast",
[MULTICAST] = "multicast",
[MULTIQUEUE] = "multiqueue",
NULL,
};
// Default NIC configuration
NICSpec* nic = &vm.nics[vm.nic_count++];
nic->mac = 0;
nic->parent[0] = '\0';
nic->budget = NICSPEC_DEFAULT_BUDGET_SIZE;
nic->flags = NICSPEC_DEFAULT_FLAGS;
nic->rx_buffer_size = 1024;
nic->tx_buffer_size = 1024;
nic->rx_bandwidth = 1000000000; /* 1 GB */
nic->tx_bandwidth = 1000000000; /* 1 GB */
nic->padding_head = 32;
nic->padding_tail = 32;
nic->pool_size = 0x400000; /* 4 MB */
char* subopts = optarg;
while(optarg && *subopts != '\0') {
char* value = NULL;
int subopt_index = getsubopt(&subopts, (char* const*)token, &value);
if(subopt_index == -1) goto failure;
switch(subopt_index) {
case EMPTY:
break;
case MAC:
if(!is_uint64(value)) goto failure;
nic->mac = strtoll(value, NULL, 16);
break;
case DEV:
strncpy(nic->parent, value, MAX_NIC_NAME_LEN);
break;
case IBUF:
if(!is_uint32(value)) goto failure;
nic->rx_buffer_size = strtoul(value, NULL, 0);
break;
case OBUF:
if(!is_uint32(value)) goto failure;
nic->tx_buffer_size = strtoul(value, NULL, 0);
break;
case IBAND:
if(!is_uint64(value)) goto failure;
nic->rx_bandwidth = strtoull(value, NULL, 0);
break;
case OBAND:
if(!is_uint64(value)) goto failure;
nic->tx_bandwidth = strtoull(value, NULL, 0);
break;
case HPAD:
if(!is_uint8(value)) goto failure;
nic->padding_head = strtoul(value, NULL, 0);
break;
case TPAD:
if(!is_uint8(value)) goto failure;
nic->padding_tail = strtoul(value, NULL, 0);
break;
case POOL:
if(!is_uint32(value)) goto failure;
nic->pool_size = strtoul(value, NULL, 16);
break;
case INHERITMAC:
if(!strcmp("on", value)) {
nic->flags |= NICSPEC_F_INHERITMAC;
} else if(!strcmp("off", value)) {
nic->flags |= NICSPEC_F_INHERITMAC;
nic->flags ^= NICSPEC_F_INHERITMAC;
} else goto failure;
break;
case NOARP:
if(!strcmp("on", value)) {
nic->flags |= NICSPEC_F_NOARP;
} else if(!strcmp("off", value)) {
nic->flags |= NICSPEC_F_NOARP;
nic->flags ^= NICSPEC_F_NOARP;
} else goto failure;
break;
case PROMISC:
if(!strcmp("on", value)) {
nic->flags |= NICSPEC_F_PROMISC;
} else if(!strcmp("off", value)) {
nic->flags |= NICSPEC_F_PROMISC;
nic->flags ^= NICSPEC_F_PROMISC;
} else goto failure;
break;
case BROADCAST:
if(!strcmp("on", value)) {
nic->flags |= NICSPEC_F_BROADCAST;
} else if(!strcmp("off", value)) {
nic->flags |= NICSPEC_F_BROADCAST;
nic->flags ^= NICSPEC_F_BROADCAST;
} else goto failure;
break;
case MULTICAST:
if(!strcmp("on", value)) {
nic->flags |= NICSPEC_F_MULTICAST;
} else if(!strcmp("off", value)) {
nic->flags |= NICSPEC_F_MULTICAST;
nic->flags ^= NICSPEC_F_MULTICAST;
} else goto failure;
break;
case MULTIQUEUE:
if(!strcmp("on", value)) {
nic->flags |= NICSPEC_F_MULTIQUEUE;
} else if(!strcmp("off", value)) {
nic->flags |= NICSPEC_F_MULTIQUEUE;
nic->flags ^= NICSPEC_F_MULTIQUEUE;
} else goto failure;
break;
default:
goto failure;
break;
}
}
break;
case 'a' :
vm.argv[vm.argc++] = strdup(optarg);
if(errno == ENOMEM) goto failure;
break;
default:
goto failure;
}
}
rpc_vm_create(rpc, &vm, callback_vm_create, NULL);
return 0;
failure:
printf("Malformed input were given\n");
help();
exit(EXIT_FAILURE);
}
unsigned long strtoul(const char *s, char **endptr, int base)
{
return strtoull(s, endptr, base);
}
