ExternalVendorCode/serval-dna
1
0
Fork 0
mirror of https://github.com/servalproject/serval-dna.git synced 2024-12-19 13:17:56 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
97884ba069
serval-dna/dna.c

747 lines
24 KiB
C
Raw Blame History

/*
Serval Distributed Numbering Architecture (DNA)
Copyright (C) 2010 Paul Gardner-Stephen
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include "serval.h"
#include "rhizome.h"
#include <stdarg.h>
#include <signal.h>
#include <unistd.h>
#include <dirent.h>
char *gatewayspec=NULL;
char *outputtemplate=NULL;
char *instrumentation_file=NULL;
char *importFile=NULL;
int debug=0;
int timeout=3000; /* 3000ms request timeout */
int serverMode=0;
int clientMode=0;
int returnMultiVars=0;
int hexdigit[16]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
int sock=-1;
#ifndef HAVE_BZERO
/* OpenWRT doesn't have bzero */
void bzero(void *m,size_t len)
{
unsigned char *c=m;
int i;
for(i=0;i<len;i++) c[i]=0;
}
#endif
int dump(char *name,unsigned char *addr,int len)
{
int i,j;
fprintf(stderr,"Dump of %s\n",name);
for(i=0;i<len;i+=16)
{
fprintf(stderr," %04x :",i);
for(j=0;j<16&&(i+j)<len;j++) fprintf(stderr," %02x",addr[i+j]);
for(;j<16;j++) fprintf(stderr," ");
fprintf(stderr," ");
for(j=0;j<16&&(i+j)<len;j++) fprintf(stderr,"%c",addr[i+j]>=' '&&addr[i+j]<0x7f?addr[i+j]:'.');
fprintf(stderr,"\n");
}
return 0;
}
int dumpResponses(struct response_set *responses)
{
struct response *r;
if (!responses) {fprintf(stderr,"Response set is NULL\n"); return 0; }
fprintf(stderr,"Response set claims to contain %d entries.\n",responses->response_count);
r=responses->responses;
while(r)
{
fprintf(stderr," response code 0x%02x\n",r->code);
if (r->next)
if (r->next->prev!=r) fprintf(stderr," !! response chain is broken\n");
r=r->next;
}
return 0;
}
#ifdef ANDROID
#include <android/log.h>
#endif
int setReason(char *fmt, ...)
{
va_list ap,ap2;
char msg[8192];
va_start(ap,fmt);
va_copy(ap2,ap);
vsnprintf(msg,8192,fmt,ap2); msg[8191]=0;
va_end(ap);
#ifdef ANDROID
__android_log_print(ANDROID_LOG_DEBUG, "servald", "%s",msg);
#endif
fprintf(stderr,"Error: %s\n",msg);
return -1;
}
int hexvalue(unsigned char c)
{
if (c>='0'&&c<='9') return c-'0';
if (c>='A'&&c<='F') return c-'A'+10;
if (c>='a'&&c<='f') return c-'a'+10;
return setReason("Invalid hex digit in SID");
}
int parseAssignment(unsigned char *text,int *var_id,unsigned char *value,int *value_len)
{
/* Parse an assignment.
Valid formats are:
var=@file - value comes from named file.
var=[[$]value] - value comes from string, and may be empty. $ means value is in hex
Values are length limited to 65535 bytes.
*/
int i;
int max_len=*value_len;
int vlen=0;
int tlen=strlen((char *)text);
if (tlen>3072) {
return setReason("Variable assignment string is too long, use =@file to read value from a file");
}
/* Identify which variable */
*var_id=-1;
for(i=0;i<tlen;i++) if (text[i]=='=') break;
/* Go through known keyring variables */
if (!strcasecmp((char *)text,"did")) *var_id=KEYTYPE_DID;
if (*var_id==-1) return setReason("Illegal variable name in assignment");
i++;
switch(text[i])
{
case '$': /* hex */
i++;
while(i<tlen) {
int b=hexvalue(text[i++])<<4;
if (i>=tlen) return setReason("Variable value has an odd number of hex digits.");
b|=hexvalue(text[i++]);
if (b<0) return setReason("That doesn't look like hex to me");
if (vlen>=max_len) return setReason("Variable hex value too long");
value[vlen++]=b;
}
*value_len=vlen;
return 0;
break;
case '@': /* file */
{
FILE *f=fopen((char *)&text[i+1],"r");
int flen;
fseek(f,0,SEEK_END);
flen=ftell(f);
if (flen>max_len) return setReason("Variable value from file too long");
fseek(f,0,SEEK_SET);
vlen=fread(value,1,flen,f);
if (vlen!=flen) return setReason("Could not read all of file");
fclose(f);
*value_len=vlen;
return 0;
}
break;
default: /* literal string */
vlen=strlen((char *)&text[i]);
if (vlen>max_len) return setReason("Variable value too long");
bcopy(&text[i],value,vlen);
*value_len=vlen;
return 0;
}
return 0;
}
int usage(char *complaint)
{
fprintf(stderr,"dna: %s\n",complaint);
fprintf(stderr,"usage:\n");
fprintf(stderr," dna [-v <flags>] -S [-f keyring file] [-N interface,...] [-G gateway specification] [-r rhizome path]\n");
fprintf(stderr,"or\n");
fprintf(stderr," dna -r <rhizome path> -M <manifest name>\n");
fprintf(stderr,"or\n");
fprintf(stderr," dna <-d|-s> id -A\n");
fprintf(stderr,"or\n");
fprintf(stderr," dna <-d|-s> id [-p pin] [-i variable instance] <-R variable[=value]>\n");
fprintf(stderr," [-v <flags>] [-t request timeout in ms] [-O output file name template]\n");
fprintf(stderr,"or\n");
fprintf(stderr," dna <-d|-s> id [-p pin] [-i variable instance] <-W|-U|-D variable[=[$|@]value]>\n");
fprintf(stderr," [-v <flags>] [-t request timeout in ms]\n");
fprintf(stderr,"or\n");
fprintf(stderr," dna [-v <flags>] [-t timeout] -d did -C\n");
fprintf(stderr,"or\n");
fprintf(stderr," dna [-v <flags>] -f <keyring file> -E <export.txt>\n");
fprintf(stderr,"\n");
fprintf(stderr," -v - Set verbosity.\n");
fprintf(stderr," -A - Ask for address of subscriber.\n");
fprintf(stderr," -b - Specify BATMAN socket to obtain peer list (flaky).\n");
fprintf(stderr," -l - Specify BATMAN socket to obtain peer list (better, but requires Serval patched BATMAN).\n");
fprintf(stderr," -L - Log mesh statistics to specified file.\n");
fprintf(stderr," -m - Return multiple variable values instead of only first response.\n");
fprintf(stderr," -M - Create and import a new bundle from the specified manifest.\n");
fprintf(stderr," -n - Do not detach from foreground in server mode.\n");
fprintf(stderr," -S - Run in server mode.\n");
fprintf(stderr," -f - Location of keyring file.\n");
fprintf(stderr," -d - Search by Direct Inward Dial (DID) number.\n");
fprintf(stderr," -s - Search by Subscriber ID (SID) number.\n");
fprintf(stderr," -p - Specify additional DNA nodes to query.\n");
fprintf(stderr," -P - Authenticate using the supplied pin.\n");
fprintf(stderr," -r - Enable Rhizome store-and-forward transport using the specified data store directory.\n");
fprintf(stderr," To limit the storage: echo space=[KB] > path/rhizome.conf\n");
fprintf(stderr," -R - Read a variable value.\n");
fprintf(stderr," -O - Place read variable value into files using argument as a template.\n");
fprintf(stderr," The following template codes can be used (interpretted by sprintf):\n");
fprintf(stderr," %%1$s - Subscriber ID\n");
fprintf(stderr," %%2$d - Variable ID (0-255)\n");
fprintf(stderr," %%3$d - Variable instance number (0-255)\n");
fprintf(stderr," -W - Write a variable value, keeping previous values.\n");
fprintf(stderr," -U - Update a variable value, replacing the previous value.\n");
fprintf(stderr," -D - Delete a variable value.\n");
fprintf(stderr," $value means interpret value as hexidecimal bytes.\n");
fprintf(stderr," @value means read value from file called value.\n");
fprintf(stderr," -C - Request the creation of a new subscriber with the specified DID.\n");
fprintf(stderr," -t - Specify the request timeout period.\n");
fprintf(stderr," -G - Offer gateway services. Argument specifies locations of necessary files.\n");
fprintf(stderr," Use -G [potato|android|custom:...] to set defaults for your device type.\n");
fprintf(stderr," -N - Specify one or more interfaces for the DNA overlay mesh to operate.\n");
fprintf(stderr," Interface specifications take the form <+|->[interface[=type][,...]\n");
fprintf(stderr," e.g., -N -en0,+ to use all interfaces except en0\n");
fprintf(stderr,"\n");
exit(-1);
}
#ifndef DNA_NO_MAIN
char *exec_args[128];
int exec_argc=0;
int servalShutdown=0;
const char *thisinstancepath=NULL;
const char *serval_instancepath()
{
if (thisinstancepath) return thisinstancepath;
const char *instancepath=getenv("SERVALINSTANCE_PATH");
if (!instancepath) instancepath=DEFAULT_INSTANCE_PATH;
return instancepath;
}
int form_serval_instance_path(char *buf, size_t bufsiz, const char *path)
{
if (snprintf(buf, bufsiz, "%s/%s", serval_instancepath(), path) < bufsiz)
return 1;
fprintf(stderr, "Cannot form pathname \"%s/%s\" -- buffer too small (%lu bytes)", serval_instancepath(), path, (unsigned long)bufsiz);
return 0;
}
int create_serval_instance_dir() {
const char *instancepath = serval_instancepath();
if (mkdir(instancepath, 0700) == -1) {
if (errno == EEXIST) {
DIR *d = opendir(instancepath);
if (!d) {
WHYF("Cannot access %s", instancepath);
perror("opendir");
return -1;
}
closedir(d);
return 0;
}
WHYF("Cannot mkdir %s", instancepath);
perror("mkdir");
return -1;
}
return 0;
}
void servalShutdownCleanly()
{
WHY("Shutting down as requested.");
/* Try to remove shutdown and PID files and exit */
char filename[1024];
if (FORM_SERVAL_INSTANCE_PATH(filename, "doshutdown")) {
unlink(filename);
}
if (FORM_SERVAL_INSTANCE_PATH(filename, "serval.pid")) {
unlink(filename);
}
if (mdp_client_socket==-1) {
if (FORM_SERVAL_INSTANCE_PATH(filename, "mdp.socket")) {
unlink(filename);
}
} else {
overlay_mdp_client_done();
}
exit(0);
}
void signal_handler( int signal ) {
if (signal==SIGQUIT) servalShutdownCleanly();
if (signal==SIGHUP||signal==SIGINT) {
/* Shut down.
The shutting down should be done from the main-line code rather than here,
so we first try to tell the mainline code to do so. If, however, this is
not the first time we have been asked to shut down, then we will do it here. */
if (servalShutdown) {
/* We have been asked before, so shut down cleanly */
servalShutdownCleanly();
} else {
WHY("Asking Serval process to shutdown cleanly");
servalShutdown=1;
}
return;
}
/* oops - caught a bad signal -- exec() ourselves fresh */
char signalName[64];
snprintf(signalName,63,"signal %d",signal); signalName[63]=0;
switch(signal) {
#ifdef SIGHUP
case SIGHUP: snprintf(signalName,63,"SIG %s (%d)","hangup",signal);
break;
#endif
#ifdef SIGINT
case SIGINT: snprintf(signalName,63,"SIG %s (%d)","interrupt",signal);
break;
#endif
#ifdef SIGQUIT
case SIGQUIT: snprintf(signalName,63,"SIG %s (%d)","quit",signal);
break;
#endif
#ifdef SIGILL
case SIGILL: snprintf(signalName,63,"SIG %s (%d)","illegal instruction (not reset when caught)",signal);
break;
#endif
#ifdef SIGTRAP
case SIGTRAP: snprintf(signalName,63,"SIG %s (%d)","trace trap (not reset when caught)",signal);
break;
#endif
#ifdef SIGABRT
case SIGABRT: snprintf(signalName,63,"SIG %s (%d)","abort()",signal);
break;
#endif
#ifdef SIGPOLL
case SIGPOLL: snprintf(signalName,63,"SIG %s (%d)","pollable event ([XSR] generated, not supported)",signal);
break;
#endif
#ifdef SIGEMT
case SIGEMT: snprintf(signalName,63,"SIG %s (%d)","EMT instruction",signal);
break;
#endif
#ifdef SIGFPE
case SIGFPE: snprintf(signalName,63,"SIG %s (%d)","floating point exception",signal);
break;
#endif
#ifdef SIGKILL
case SIGKILL: snprintf(signalName,63,"SIG %s (%d)","kill (cannot be caught or ignored)",signal);
break;
#endif
#ifdef SIGBUS
case SIGBUS: snprintf(signalName,63,"SIG %s (%d)","bus error",signal);
break;
#endif
#ifdef SIGSEGV
case SIGSEGV: snprintf(signalName,63,"SIG %s (%d)","segmentation violation",signal);
break;
#endif
#ifdef SIGSYS
case SIGSYS: snprintf(signalName,63,"SIG %s (%d)","bad argument to system call",signal);
break;
#endif
#ifdef SIGPIPE
case SIGPIPE: snprintf(signalName,63,"SIG %s (%d)","write on a pipe with no one to read it",signal);
break;
#endif
#ifdef SIGALRM
case SIGALRM: snprintf(signalName,63,"SIG %s (%d)","alarm clock",signal);
break;
#endif
#ifdef SIGTERM
case SIGTERM: snprintf(signalName,63,"SIG %s (%d)","software termination signal from kill",signal);
break;
#endif
#ifdef SIGURG
case SIGURG: snprintf(signalName,63,"SIG %s (%d)","urgent condition on IO channel",signal);
break;
#endif
#ifdef SIGSTOP
case SIGSTOP: snprintf(signalName,63,"SIG %s (%d)","sendable stop signal not from tty",signal);
break;
#endif
#ifdef SIGTSTP
case SIGTSTP: snprintf(signalName,63,"SIG %s (%d)","stop signal from tty",signal);
break;
#endif
#ifdef SIGCONT
case SIGCONT: snprintf(signalName,63,"SIG %s (%d)","continue a stopped process",signal);
break;
#endif
#ifdef SIGCHLD
case SIGCHLD: snprintf(signalName,63,"SIG %s (%d)","to parent on child stop or exit",signal);
break;
#endif
#ifdef SIGTTIN
case SIGTTIN: snprintf(signalName,63,"SIG %s (%d)","to readers pgrp upon background tty read",signal);
break;
#endif
#ifdef SIGTTOU
case SIGTTOU: snprintf(signalName,63,"SIG %s (%d)","like TTIN for output if (tp->t_local&LTOSTOP)",signal);
break;
#endif
#ifdef SIGIO
#if SIGIO != SIGPOLL
case SIGIO: snprintf(signalName,63,"SIG %s (%d)","input/output possible signal",signal);
break;
#endif
#endif
#ifdef SIGXCPU
case SIGXCPU: snprintf(signalName,63,"SIG %s (%d)","exceeded CPU time limit",signal);
break;
#endif
#ifdef SIGXFSZ
case SIGXFSZ: snprintf(signalName,63,"SIG %s (%d)","exceeded file size limit",signal);
break;
#endif
#ifdef SIGVTALRM
case SIGVTALRM: snprintf(signalName,63,"SIG %s (%d)","virtual time alarm",signal);
break;
#endif
#ifdef SIGPROF
case SIGPROF: snprintf(signalName,63,"SIG %s (%d)","profiling time alarm",signal);
break;
#endif
#ifdef SIGWINCH
case SIGWINCH: snprintf(signalName,63,"SIG %s (%d)","window size changes",signal);
break;
#endif
#ifdef SIGINFO
case SIGINFO: snprintf(signalName,63,"SIG %s (%d)","information request",signal);
break;
#endif
#ifdef SIGUSR1
case SIGUSR1: snprintf(signalName,63,"SIG %s (%d)","user defined signal 1",signal);
break;
#endif
#ifdef SIGUSR2
case SIGUSR2: snprintf(signalName,63,"SIG %s (%d)","user defined signal 2",signal);
break;
#endif
}
signalName[63]=0;
fprintf(stderr,"Caught terminal signal %s -- respawning.\n",signalName);
if (sock>-1) close(sock);
int i;
for(i=0;i<overlay_interface_count;i++)
if (overlay_interfaces[i].fd>-1)
close(overlay_interfaces[i].fd);
execv(exec_args[0],exec_args);
/* Quit if the exec() fails */
exit(-3);
}
int setVerbosity(char *optarg) {
long long old_debug=debug;
debug=strtoll(optarg,NULL,10);
if (strstr(optarg,"interfaces")) debug|=DEBUG_OVERLAYINTERFACES;
if (strstr(optarg,"rx")) debug|=DEBUG_PACKETRX;
if (strstr(optarg,"tx")) debug|=DEBUG_PACKETTX;
if (strstr(optarg,"verbose")) debug|=DEBUG_VERBOSE;
if (strstr(optarg,"verbio")) debug|=DEBUG_VERBOSE_IO;
if (strstr(optarg,"peers")) debug|=DEBUG_PEERS;
if (strstr(optarg,"dnaresponses")) debug|=DEBUG_DNARESPONSES;
if (strstr(optarg,"dnarequests")) debug|=DEBUG_DNAREQUESTS;
if (strstr(optarg,"simulation")) debug|=DEBUG_SIMULATION;
if (strstr(optarg,"dnavars")) debug|=DEBUG_DNAVARS;
if (strstr(optarg,"packetformats")) debug|=DEBUG_PACKETFORMATS;
if (strstr(optarg,"packetconstruction")) debug|=DEBUG_PACKETCONSTRUCTION;
if (strstr(optarg,"gateway")) debug|=DEBUG_GATEWAY;
if (strstr(optarg,"hlr")) debug|=DEBUG_HLR;
if (strstr(optarg,"sockio")) debug|=DEBUG_IO;
if (strstr(optarg,"frames")) debug|=DEBUG_OVERLAYFRAMES;
if (strstr(optarg,"abbreviations")) debug|=DEBUG_OVERLAYABBREVIATIONS;
if (strstr(optarg,"routing")) debug|=DEBUG_OVERLAYROUTING;
if (strstr(optarg,"security")) debug|=DEBUG_SECURITY;
if (strstr(optarg,"rhizome")) debug|=DEBUG_RHIZOME;
if (strstr(optarg,"norhizome"))
{ debug|=DEBUG_DISABLERHIZOME; debug&=~DEBUG_RHIZOME; }
if (strstr(optarg,"filesync")) debug|=DEBUG_RHIZOMESYNC;
if (strstr(optarg,"monitorroutes")) debug|=DEBUG_OVERLAYROUTEMONITOR;
if (strstr(optarg,"queues")) debug|=DEBUG_QUEUES;
if (strstr(optarg,"broadcasts")) debug|=DEBUG_BROADCASTS;
if (old_debug==debug) {
fprintf(stderr,"WARNING: Option '%s' had no effect on existing debug/verbosity level.\n",
optarg);
}
return 0;
}
int main(int argc, char **argv)
{
int c;
char *pin=NULL;
char *did=NULL;
char *sid=NULL;
char *keyring_file=NULL;
int instance=-1;
int foregroundMode=0;
memabuseInit();
#if defined WIN32
WSADATA wsa_data;
WSAStartup(MAKEWORD(1,1), &wsa_data);
#else
/* Catch sigsegv and other crash signals so that we can relaunch ourselves */
for(exec_argc=0;exec_argc<argc;exec_argc++)
exec_args[exec_argc]=strdup(argv[exec_argc]);
exec_args[exec_argc]=0;
signal( SIGSEGV, signal_handler );
signal( SIGFPE, signal_handler );
signal( SIGILL, signal_handler );
signal( SIGBUS, signal_handler );
signal( SIGABRT, signal_handler );
/* Catch SIGHUP etc so that we can respond to requests to do things */
signal( SIGHUP, signal_handler );
signal( SIGINT, signal_handler );
signal( SIGQUIT, signal_handler );
#endif
srandomdev();
if (argv[1]&&argv[1][0]!='-') {
/* First argument doesn't start with a dash, so assume it is for the new command line
parser. */
/* Don't include name of program in arguments */
int return_value = parseCommandLine(argc - 1, (const char*const*)&argv[1]);
#if defined WIN32
WSACleanup();
#endif
return return_value;
}
fprintf(stderr,
"WARNING: The use of the old command line structure is being deprecated.\n"
" Type '%s help' to learn about the new command line structure.\n",
argv[0]);
while((c=getopt(argc,argv,"Ab:B:E:G:I:Sf:d:i:l:L:mnp:P:r:s:t:v:R:W:U:D:CO:M:N:")) != -1 )
{
switch(c)
{
case 'S': serverMode=1; break;
case 'r': /* Enable rhizome */
if (rhizome_datastore_path) return WHY("-r specified more than once");
rhizome_datastore_path=optarg;
rhizome_opendb();
/* Also set keyring file to be in the Rhizome directory, to save the need to specify it
separately. */
char temp[1024];
if (snprintf(temp, sizeof(temp), "%s/serval.keyring", optarg)
>= sizeof(temp))
exit(WHY("Rhizome directory name too long."));
keyring_file = strdup(temp);
break;
case 'M': /* Distribute specified manifest and file pair using Rhizome. */
/* This option assumes that the manifest is locally produced, and will
create any appropriate signatures, replacing any old signatures on the
manifest.
A different calling would be required to import an existing pre-signed
manifest */
return rhizome_bundle_import(NULL, NULL, optarg,
NULL /* no groups - XXX should allow them */,
255 /* ttl - XXX should read from somewhere,
e.g., bar if being imported */,
0 /* int verifyP */,
1 /* int checkFileP */,
1 /* int signP */);
break;
case 'm': returnMultiVars=1; break;
case 'N': /* Ask for overlay network to setup one or more interfaces */
if (overlay_interface_args(optarg))
return WHY("Invalid interface specification(s) passed to -N");
overlayMode=1;
break;
case 'G': /* Offer gateway services */
gatewayspec=strdup(optarg);
if(prepareGateway(gatewayspec)) return usage("Invalid gateway specification");
break;
case 'n': /* don't detach from foreground in server mode */
foregroundMode=1; break;
case 'b': /* talk peers on a BATMAN mesh */
batman_socket=strdup(optarg);
break;
case 'l': /* talk peers on a BATMAN mesh */
batman_peerfile=strdup(optarg);
break;
case 'L':
instrumentation_file=strdup(optarg);
break;
case 'B': /* Set simulated Bit Error Rate for bench-testing */
simulatedBER=atof(optarg);
fprintf(stderr,"WARNING: Bit error injection enabled -- this will cause packet loss and is intended only for testing.\n");
break;
case 'i':
instance=atoi(optarg);
if (instance<-1||instance>255) usage("Illegal variable instance ID.");
break;
case 'f':
if (clientMode) usage("Only servers use keyring files");
keyring_file=strdup(optarg);
break;
case 'p': /* additional peers to query */
if (additionalPeer(optarg)) exit(-3);
break;
case 'P': /* Supply pin */
pin=strdup(optarg);
clientMode=1;
break;
case 'd': /* Ask by DID */
clientMode=1;
did=strdup(optarg);
break;
case 's': /* Ask by subscriber ID */
clientMode=1;
sid=strdup(optarg);
break;
case 't': /* request timeout (ms) */
timeout=atoi(optarg);
break;
case 'v': /* set verbosity */
setVerbosity(optarg);
break;
case 'A': /* get address (IP or otherwise) of a given peer */
peerAddress(did,sid,3 /* 1 = print list of addresses to stdout, 2 = set peer list to responders */);
break;
case 'R': /* read a variable */
{
unsigned char buffer[65535];
int len=0;
requestItem(did,sid,(char *)optarg,instance,buffer,sizeof(buffer),&len,NULL);
}
break;
case 'W': /* write a variable */
{
int var_id;
unsigned char value[65536];
int value_len=65535;
if (parseAssignment((unsigned char *)optarg,&var_id,value,&value_len)) return -1;
value[value_len]=0;
return writeItem(did?did:sid,var_id,instance,value,0,value_len,SET_NOREPLACE,-1,NULL);
}
break;
case 'U': /* write or update a variable */
{
int var_id;
unsigned char value[65536];
int value_len=65535;
if (parseAssignment((unsigned char *)optarg,&var_id,value,&value_len)) return -1;
value[value_len]=0;
return writeItem(did?did:sid,var_id,instance,value,0,value_len,SET_REPLACE,-1,NULL);
}
break;
case 'C': /* create a new keyring entry */
return WHY("Entries in new keyring format must be used with new command line framework.");
break;
case 'O': /* output to templated files */
if (outputtemplate) usage("You can only specify -O once");
outputtemplate=strdup(optarg);
break;
default:
usage("Invalid option");
break;
}
}
if (optind<argc) usage("Extraneous options at end of command");
if (keyring_file&&clientMode) usage("Only servers use backing files");
if (serverMode&&clientMode) usage("You asked me to be both server and client. That's silly.");
if (serverMode) return server(keyring_file,foregroundMode);
if (!clientMode) usage("Serval server and client utility.");
#if defined WIN32
WSACleanup();
#endif
/* Client mode: */
return 0;
}
#endif
long long parse_quantity(char *q)
{
int m;
char units[80];
if (strlen(q)>=80) return WHY("quantity string >=80 characters");
if (sscanf(q,"%d%s",&m,units)==2)
{
if (units[1]) return WHY("Units should be single character");
switch(units[0])
{
case 'k': return m*1000LL;
case 'K': return m*1024LL;
case 'm': return m*1000LL*1000LL;
case 'M': return m*1024LL*1024LL;
case 'g': return m*1000LL*1000LL*1000LL;
case 'G': return m*1024LL*1024LL*1024LL;
default:
return WHY("Illegal unit: should be k,K,m,M,g, or G.");
}
}
if (sscanf(q,"%d",&m)==1)
{
return m;
}
else
{
return WHY("Could not parse quantity");
}
}
Reference in New Issue View Git Blame Copy Permalink