static obj_ptr _map_find(obj_ptr args, obj_ptr env)
{
int ct = _length(args);
obj_ptr map, key, res;
if (ct < 2 || ct > 3)
return MKERROR_STRING(MKSTRING("Syntax: (map-find map key [default])"));
map = CAR(args);
if (NMAPP(map))
return MKERROR(MKSTRING("Expected a map in first arg to map-find"), map);
key = CADR(args);
res = map_find(&MAP(map), key);
if (!res)
{
if (ct == 3)
return CADDR(args);
else
return MKERROR(MKSTRING("Key not found."), key);
}
return res;
}
void transcode::startwithSetupFile()
{
uint8_t *test;
((Context*)ctx)->addDictStr(MKSTRING(global.settings.filename), (uint8_t*)((std::string *)baseName)->c_str());
((Context*)ctx)->addDict<uint32_t>(MKSTRING(global.settings.segmentSizeInSeconds), segmentSizeInSeconds);
((Context*)ctx)->addDict<uint32_t>(MKSTRING(global.settings.fps), fps);
((isom*)container)->open((IBuffer*)buffer);
((Context *) ctx)->getDict(MKSTRING(global.settings.filename), &test);
((isom*)container)->skipToMDAT();
// try to read the bitstream
obuffer = new synchronizedObjectBuffer<Sample>();
((Context*)ctx)->setSampleBuffer(obuffer);
demuxer = new demux((Context *)ctx, (IFormat*)container);
mde_log(MDE_LOG_DEBUG,"MDE: running demultiplexer... \n");
((demux *)demuxer)->run();
mde_log(MDE_LOG_DEBUG, "MDE: init muxer...");
multiplexer *muxer = new multiplexer((Context*) ctx, ISOM_CONTAINER, FRAGMENTED_ISOM);
mde_log(MDE_LOG_DEBUG, "MDE: running muxer...");
muxer->run();
}
static obj_ptr _mod(obj_ptr arg1, obj_ptr arg2, obj_ptr env)
{
if (NINTP(arg1))
return MKERROR(MKSTRING("Expected an integer first argument in %"), arg1);
if (NINTP(arg2))
return MKERROR(MKSTRING("Expected an integer second argument in %"), arg2);
return MKINT(INT(arg1) % INT(arg2));
}
static obj_ptr _cdr(obj_ptr arg, obj_ptr env)
{
if (NCONSP(arg))
return MKERROR(MKSTRING("Expected a pair in cdr"), arg);
return CDR(arg);
}
static obj_ptr _map_size(obj_ptr arg, obj_ptr env)
{
if (NMAPP(arg))
return MKERROR(MKSTRING("Expected a map in map-clear"), arg);
return MKINT(map_size(&MAP(arg)));
}
static obj_ptr _vec_length(obj_ptr arg, obj_ptr env)
{
if (NVECP(arg))
return MKERROR(MKSTRING("Expected a vector in vec-length"), arg);
return MKINT(vec_length(&VEC(arg)));
}
static obj_ptr _add(obj_ptr args, obj_ptr env)
{
obj_ptr res = MKINT(0);
for (; CONSP(args); args = CDR(args))
{
obj_ptr arg = CAR(args);
if (INTP(arg))
{
if (FLOATP(res))
FLOAT(res) += (double)INT(arg);
else
INT(res) += INT(arg);
}
else if (FLOATP(arg))
{
if (INTP(res))
{
int n = INT(res);
res->type = TYPE_FLOAT;
FLOAT(res) = (double)n;
}
FLOAT(res) += FLOAT(arg);
}
else
{
res = MKERROR(MKSTRING("Expected a number in +"), arg);
break;
}
}
return res;
}
static obj_ptr _map_delete(obj_ptr arg1, obj_ptr arg2, obj_ptr env)
{
if (NMAPP(arg1))
return MKERROR(MKSTRING("Expected a map in map-delete"), arg1);
return MKBOOL(map_delete(&MAP(arg1), arg2));
}
static obj_ptr _load(obj_ptr arg, obj_ptr env)
{
if (NSTRINGP(arg))
return MKERROR(MKSTRING("Expected a string argument in (load ...)"), arg);
return _load_imp(CPTR(arg), env);
}
/* dump the full box inclusive header and all included boxes */
chunk *DREFBox::dumpBox(dictionary *inputParams)
{
uint32_t i, n, size;
/* compute the size of the box */
box.fullbox.header.size = (uint64_t) estimateSize(inputParams);
chunk *c = new chunk((uint32_t) box.fullbox.header.size, false);
inputParams->getDict(MKSTRING(dref.entry_count), &box.entry_count);
size = htonl((uint32_t) box.fullbox.header.size);
box.fullbox.header.type = htonl(DREF_BOX);
box.fullbox.version = htonl(0);
box.fullbox.flags[0] = box.fullbox.flags[1] = box.fullbox.flags[2] = 0;
box.entry_count = htonl(box.entry_count);
c->append((uint8_t*) &size, sizeof(uint32_t));
c->append((uint8_t*) &box.fullbox.header.type, sizeof(uint32_t));
c->append((uint8_t*) &box.fullbox.version, sizeof(box.fullbox.version));
c->append((uint8_t*) &box.fullbox.flags[0], sizeof(uint8_t));
c->append((uint8_t*) &box.fullbox.flags[1], sizeof(uint8_t));
c->append((uint8_t*) &box.fullbox.flags[2], sizeof(uint8_t));
c->append((uint8_t*) &box.entry_count, sizeof(uint32_t));
for(i=0;i<boxes.size();i++) c->append(boxes.at(i)->dumpBox(inputParams));
return c;
}
static obj_ptr _vec_clear(obj_ptr arg, obj_ptr env)
{
if (NVECP(arg))
return MKERROR(MKSTRING("Expected a vector in vec-clear"), arg);
vec_clear(&VEC(arg));
return NIL;
}
static obj_ptr _map_add(obj_ptr arg1, obj_ptr arg2, obj_ptr arg3, obj_ptr env)
{
if (NMAPP(arg1))
return MKERROR(MKSTRING("Expected a map in map-add"), arg1);
map_add(&MAP(arg1), arg2, arg3);
return NIL;
}
static obj_ptr _map_clear(obj_ptr arg, obj_ptr env)
{
if (NMAPP(arg))
return MKERROR(MKSTRING("Expected a map in map-clear"), arg);
map_clear(&MAP(arg));
return NIL;
}
static obj_ptr _decrement(obj_ptr arg, obj_ptr env)
{
if (INTP(arg))
return MKINT(INT(arg) - 1);
if (FLOATP(arg))
return MKFLOAT(FLOAT(arg) - 1.0);
return MKERROR(MKSTRING("Expected a number in --"), arg);
}
static obj_ptr _vec_add(obj_ptr args, obj_ptr env)
{
obj_ptr arg = CAR(args);
if (NVECP(arg))
return MKERROR(MKSTRING("Expected a vector in vec-add"), arg);
_vec_add_imp(&VEC(arg), CDR(args), env);
return NIL;
}
static obj_ptr _vec_get(obj_ptr arg1, obj_ptr arg2, obj_ptr env)
{
vec_ptr v;
int n;
if (NVECP(arg1))
return MKERROR(MKSTRING("Expected a vector for the first arg in vec-get"), arg1);
if (NINTP(arg2))
return MKERROR(MKSTRING("Expected an integer for the second arg in vec-get"), arg2);
v = &VEC(arg1);
n = INT(arg2);
if (n < 0 || n >= vec_length(v))
return MKERROR(MKSTRING("Index out of bounds in vec-get"), arg2);
return vec_get(v, n);
}
static obj_ptr _sub(obj_ptr args, obj_ptr env)
{
obj_ptr res = MKINT(0);
int ct = 0;
for (; CONSP(args); args = CDR(args))
{
obj_ptr arg = CAR(args);
ct++;
if (NINTP(arg) && NFLOATP(arg))
{
res = MKERROR(MKSTRING("Expected a number in -"), arg);
return res;
}
else if (ct == 1)
{
if (INTP(arg))
INT(res) = INT(arg);
else
{
res->type = TYPE_FLOAT;
FLOAT(res) = FLOAT(arg);
}
}
else if (INTP(arg))
{
if (FLOATP(res))
FLOAT(res) -= (double)INT(arg);
else
INT(res) -= INT(arg);
}
else if (FLOATP(arg))
{
if (INTP(res))
{
int n = INT(res);
res->type = TYPE_FLOAT;
FLOAT(res) = (double)n;
}
FLOAT(res) -= FLOAT(arg);
}
}
if (ct == 1)
{
if (INTP(res))
INT(res) *= -1;
else
FLOAT(res) *= -1;
}
return res;
}
static obj_ptr _floor(obj_ptr arg, obj_ptr env)
{
if (INTP(arg))
return arg;
if (FLOATP(arg))
{
int x = (int)FLOAT(arg);
return MKINT(x);
}
return MKERROR(MKSTRING("Expected a number in floor"), arg);
}
static obj_ptr _map_keys(obj_ptr arg, obj_ptr env)
{
obj_ptr res = NIL;
map_iter_t i;
map_node_ptr n;
if (NMAPP(arg))
return MKERROR(MKSTRING("Expected a map in map-keys"), arg);
i = map_get_iter(&MAP(arg));
for (n = map_next(&i); n; n = map_next(&i))
res = CONS(n->key, res);
return res;
}
void init_macro()
{
int n=0;
Macros = NULL;
nMacros = 0;
MacroError = 0;
strcpy(MacroWarning, "");
RunningMacro = 0;
while (MacroCmds[n].cmd) n++;
nMacroCmds = n;
xMacroCmdStrs = (XmString *)XtMalloc(n * sizeof(XmString));
for (n=0; n<nMacroCmds; n++) {
xMacroCmdStrs[n] = MKSTRING(MacroCmds[n].cmd);
}
}
static obj_ptr _div(obj_ptr args, obj_ptr env)
{
obj_ptr res = MKFLOAT(0);
int ct = 0;
for (; CONSP(args); args = CDR(args))
{
obj_ptr arg = CAR(args);
ct++;
if (NINTP(arg) && NFLOATP(arg))
{
res = MKERROR(MKSTRING("Expected a number in /"), arg);
return res;
}
else if (ct == 1)
{
if (INTP(arg))
FLOAT(res) = (double)INT(arg);
else
FLOAT(res) = FLOAT(arg);
}
else if (INTP(arg))
{
FLOAT(res) /= (double)INT(arg);
}
else if (FLOATP(arg))
{
FLOAT(res) /= FLOAT(arg);
}
}
if (ct == 1)
{
FLOAT(res) = 1 / FLOAT(res);
}
return res;
}
void main()
{
int rc;
if (cloud_init())
exit(1);
// This is where we actually register the cursom do_commands.
// Note use of the '#' (enquote) operator to turn the variable
// names into strings. [The double macro indirection is required to
// get this to work!]. NOTE: this registration must be done after
// cloud_init(), since cloud_init() clears the do_command table.
#define MKS(x) #x
#define MKSTRING(x) MKS(x)
cloud_register_target(TARGET_NAME_1,
MKSTRING(REQ_VAR_NAME_1), MKSTRING(REPLY_VAR_NAME_1));
cloud_register_target(TARGET_NAME_2,
MKSTRING(REQ_VAR_NAME_2), MKSTRING(REPLY_VAR_NAME_2));
cloud_register_target(TARGET_NAME_3,
MKSTRING(REQ_VAR_NAME_3), MKSTRING(REPLY_VAR_NAME_3));
_restart:
do {
rc = cloud_tick();
} while (!rc);
printf("Final rc = %d\n", rc);
if (rc == -NETERR_ABORT) {
// RCI reboot request was received. Normally we would use this
// to shut down cleanly and reboot the board.
printf("Rebooting via exit(0)!\n");
exit(0);
}
goto _restart;
}
#endif
// Turn this back off in release mode.
#ifdef NDEBUG
#undef _DEBUG
#endif
#elif POSIX
#define __cdecl
#endif
#if defined(USE_LIGHT_MEM_DEBUG) || defined(USE_MEM_DEBUG)
#pragma optimize( "", off )
#define inline
#endif
const char *g_pszModule = MKSTRING( MEMOVERRIDE_MODULE );
inline void *AllocUnattributed( size_t nSize )
{
#if !defined(USE_LIGHT_MEM_DEBUG) && !defined(USE_MEM_DEBUG)
return MemAlloc_Alloc(nSize);
#else
return MemAlloc_Alloc(nSize, g_pszModule, 0);
#endif
}
inline void *ReallocUnattributed( void *pMem, size_t nSize )
{
#if !defined(USE_LIGHT_MEM_DEBUG) && !defined(USE_MEM_DEBUG)
return g_pMemAlloc->Realloc(pMem, nSize);
#else
return g_pMemAlloc->Realloc(pMem, nSize, g_pszModule, 0);
int
main(int argc,char *argv[])
{
int arg,ret=KEYSERVER_INTERNAL_ERROR,i;
char line[MAX_LINE];
char *thekey=NULL;
long follow_redirects=5;
char *proxy=NULL;
curl_version_info_data *curldata;
struct curl_slist *headers=NULL;
console=stderr;
/* Kludge to implement standard GNU options. */
if (argc > 1 && !strcmp (argv[1], "--version"))
{
printf ("gpgkeys_curl (GnuPG) %s\n", VERSION);
printf ("Uses: %s\n", curl_version());
return 0;
}
else if (argc > 1 && !strcmp (argv[1], "--help"))
{
show_help (stdout);
return 0;
}
while((arg=getopt(argc,argv,"hVo:"))!=-1)
switch(arg)
{
default:
case 'h':
show_help (console);
return KEYSERVER_OK;
case 'V':
fprintf(stdout,"%d\n%s\n",KEYSERVER_PROTO_VERSION,VERSION);
return KEYSERVER_OK;
case 'o':
output=fopen(optarg,"wb");
if(output==NULL)
{
fprintf(console,"gpgkeys: Cannot open output file `%s': %s\n",
optarg,strerror(errno));
return KEYSERVER_INTERNAL_ERROR;
}
break;
}
if(argc>optind)
{
input=fopen(argv[optind],"r");
if(input==NULL)
{
fprintf(console,"gpgkeys: Cannot open input file `%s': %s\n",
argv[optind],strerror(errno));
return KEYSERVER_INTERNAL_ERROR;
}
}
if(input==NULL)
input=stdin;
if(output==NULL)
output=stdout;
opt=init_ks_options();
if(!opt)
return KEYSERVER_NO_MEMORY;
/* Get the command and info block */
while(fgets(line,MAX_LINE,input)!=NULL)
{
int err;
char option[MAX_OPTION+1];
if(line[0]=='\n')
break;
err=parse_ks_options(line,opt);
if(err>0)
{
ret=err;
goto fail;
}
else if(err==0)
continue;
if(sscanf(line,"OPTION %" MKSTRING(MAX_OPTION) "s\n",option)==1)
{
int no=0;
char *start=&option[0];
option[MAX_OPTION]='\0';
if(ascii_strncasecmp(option,"no-",3)==0)
{
no=1;
start=&option[3];
}
if(ascii_strncasecmp(start,"http-proxy",10)==0)
{
/* Safe to not check the return code of strdup() here.
If it fails, we simply won't use a proxy. */
if(no)
{
free(proxy);
proxy=strdup("");
}
else if(start[10]=='=')
{
if(strlen(&start[11])<MAX_PROXY)
{
free(proxy);
proxy=strdup(&start[11]);
}
}
}
else if(ascii_strncasecmp(start,"follow-redirects",16)==0)
{
if(no)
follow_redirects=0;
else if(start[16]=='=')
follow_redirects=atoi(&start[17]);
else if(start[16]=='\0')
follow_redirects=-1;
}
continue;
}
}
if(!opt->scheme)
{
fprintf(console,"gpgkeys: no scheme supplied!\n");
ret=KEYSERVER_SCHEME_NOT_FOUND;
goto fail;
}
if(!opt->host)
{
fprintf(console,"gpgkeys: no keyserver host provided\n");
goto fail;
}
if(opt->timeout && register_timeout()==-1)
{
fprintf(console,"gpgkeys: unable to register timeout handler\n");
return KEYSERVER_INTERNAL_ERROR;
}
curl_global_init(CURL_GLOBAL_DEFAULT);
curl=curl_easy_init();
if(!curl)
{
fprintf(console,"gpgkeys: unable to initialize curl\n");
ret=KEYSERVER_INTERNAL_ERROR;
goto fail;
}
/* Make sure we have the protocol the user is asking for so we can
print a nicer error message. */
curldata=curl_version_info(CURLVERSION_NOW);
for(i=0;curldata->protocols[i];i++)
if(ascii_strcasecmp(curldata->protocols[i],opt->scheme)==0)
break;
if(curldata->protocols[i]==NULL)
{
fprintf(console,"gpgkeys: protocol `%s' not supported\n",opt->scheme);
ret=KEYSERVER_SCHEME_NOT_FOUND;
goto fail;
}
if(follow_redirects)
{
curl_easy_setopt(curl,CURLOPT_FOLLOWLOCATION,1L);
if(follow_redirects>0)
curl_easy_setopt(curl,CURLOPT_MAXREDIRS,follow_redirects);
}
if(opt->auth)
curl_easy_setopt(curl,CURLOPT_USERPWD,opt->auth);
if(opt->debug)
{
fprintf(console,"gpgkeys: curl version = %s\n",curl_version());
curl_easy_setopt(curl,CURLOPT_STDERR,console);
curl_easy_setopt(curl,CURLOPT_VERBOSE,1L);
}
curl_easy_setopt(curl,CURLOPT_SSL_VERIFYPEER,(long)opt->flags.check_cert);
if (opt->ca_cert_file)
curl_easy_setopt (curl, CURLOPT_CAINFO, opt->ca_cert_file);
/* Avoid caches to get the most recent copy of the key. This is bug
#1061. In pre-curl versions of the code, we didn't do it. Then
we did do it (as a curl default) until curl changed the default.
Now we're doing it again, but in such a way that changing
defaults in the future won't impact us. We set both the Pragma
and Cache-Control versions of the header, so we're good with both
HTTP 1.0 and 1.1. */
headers=curl_slist_append(headers,"Pragma: no-cache");
if(headers)
headers=curl_slist_append(headers,"Cache-Control: no-cache");
if(!headers)
{
fprintf(console,"gpgkeys: out of memory when building HTTP headers\n");
ret=KEYSERVER_NO_MEMORY;
goto fail;
}
curl_easy_setopt(curl,CURLOPT_HTTPHEADER,headers);
if(proxy)
curl_easy_setopt(curl,CURLOPT_PROXY,proxy);
/* If it's a GET or a SEARCH, the next thing to come in is the
keyids. If it's a SEND, then there are no keyids. */
if(opt->action==KS_GET)
{
/* Eat the rest of the file */
for(;;)
{
if(fgets(line,MAX_LINE,input)==NULL)
break;
else
{
if(line[0]=='\n' || line[0]=='\0')
break;
if(!thekey)
{
thekey=strdup(line);
if(!thekey)
{
fprintf(console,"gpgkeys: out of memory while "
"building key list\n");
ret=KEYSERVER_NO_MEMORY;
goto fail;
}
/* Trim the trailing \n */
thekey[strlen(line)-1]='\0';
}
}
}
}
else
{
fprintf(console,
"gpgkeys: this keyserver type only supports key retrieval\n");
goto fail;
}
if(!thekey)
{
fprintf(console,"gpgkeys: invalid keyserver instructions\n");
goto fail;
}
/* Send the response */
fprintf(output,"VERSION %d\n",KEYSERVER_PROTO_VERSION);
fprintf(output,"PROGRAM %s\n\n",VERSION);
if(opt->verbose)
{
fprintf(console,"Scheme:\t\t%s\n",opt->scheme);
fprintf(console,"Host:\t\t%s\n",opt->host);
if(opt->port)
fprintf(console,"Port:\t\t%s\n",opt->port);
if(opt->path)
fprintf(console,"Path:\t\t%s\n",opt->path);
fprintf(console,"Command:\tGET\n");
}
set_timeout(opt->timeout);
ret=get_key(thekey);
fail:
free(thekey);
if(input!=stdin)
fclose(input);
if(output!=stdout)
fclose(output);
free_ks_options(opt);
curl_slist_free_all(headers);
if(curl)
curl_easy_cleanup(curl);
free(proxy);
curl_global_cleanup();
return ret;
}
/**
\fn main
*/
int main(int argc, char *argv[])
{
#if defined(_WIN32)
redirectStdoutToFile();
#endif
#if !defined(NDEBUG) && defined(FIND_LEAKS)
new_progname = argv[0];
#endif
installSigHandler();
bool portableMode=isPortableMode(argc,argv);
printf("*************************\n");
printf(" Avidemux v" VERSION);
#if defined(ADM_SUBVERSION)
#define MKSTRING(x) x
printf(" (%s)", MKSTRING(ADM_SUBVERSION));
#endif
printf("\n*************************\n");
printf(" http://www.avidemux.org\n");
printf(" Code : Mean, JSC, Gruntster \n");
printf(" GFX : Nestor Di , [email protected]\n");
printf(" Design : Jakub Misak\n");
printf(" FreeBSD : Anish Mistry, [email protected]\n");
printf(" Audio : Mihail Zenkov\n");
printf(" MacOsX : Kuisathaverat\n");
printf(" Win32 : Gruntster\n\n");
#ifdef __GNUC__
printf("Compiler: GCC %s\n", __VERSION__);
#endif
printf("Build Target: ");
#if defined(_WIN32)
printf("Microsoft Windows");
#elif defined(__APPLE__)
printf("Apple");
#else
printf("Linux");
#endif
#if defined(ADM_CPU_X86_32)
printf(" (x86)");
#elif defined(ADM_CPU_X86_64)
printf(" (x86-64)");
#endif
printf("\n");
#ifdef _WIN32
char version[250];
if (getWindowsVersion(version))
printf("Operating System: %s\n", version);
#endif
#if defined(__USE_LARGEFILE) && defined(__USE_LARGEFILE64)
printf("\nLarge file available: %d offset\n", __USE_FILE_OFFSET64);
#endif
#ifndef __APPLE__
ADM_InitMemcpy();
#endif
atexit(onexit);
#ifdef _WIN32
win32_netInit();
#endif
#if 0
// Hook our UI...
InitFactory();
InitCoreToolkit();
initFileSelector();
#endif
// Load .avidemuxrc
quotaInit();
ADM_initBaseDir(portableMode);
// Init jobs
ADMJob::jobInit();
jobRun(argc,argv);
uninstallSigHandler();
printf("Normal exit\n");
return 0;
}
static Widget createContents(Widget parent, SpaceWindow *window,
int hasEventBar, char *eventBarText)
{
Arg args[50];
int ac;
XmString s1, s2;
char ctmp[10];
Widget form, displayMode, stability, particleType, rotation, stats;
Widget formt1, allSliders;
Widget controls, trackInfoFrame, trackInfo;
Widget scaleFrame, scaleRC, scaleLabel, scaleArea;
Widget stabilityLabel, particleTypeLabel;
Widget eventCtrlFrame, eventCtrlForm, eventNumLabel, upArrow;
Widget eventNumText, downArrow, eventCtrlText;
Widget widget, spin;
Pixel foreground, background;
Pixmap pm;
/* Create the form onto which everything goes */
ac = 0;
XtSetArg(args[ac], XmNmarginHeight, 0); ac++;
form = XmCreateForm(parent, "form", args, ac);
XtManageChild(form);
if (hasEventBar) {
ac = 0;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
eventCtrlFrame = XmCreateFrame(form, "eventCtrlFrame", args, ac);
XtManageChild(eventCtrlFrame);
ac = 0;
eventCtrlForm = XmCreateForm(eventCtrlFrame, "eventCtrlForm", args, ac);
XtManageChild(eventCtrlForm);
ac = 0;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNlabelString, (s1=MKSTRING("Event #"))); ac++;
eventNumLabel = (Widget) XmCreateLabelGadget(
eventCtrlForm, "eventNumLabel",
args, ac);
XmStringFree(s1);
XtManageChild(eventNumLabel);
ac = 0;
XtSetArg(args[ac], XmNarrowDirection, XmARROW_UP); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNleftWidget, eventNumLabel); ac++;
upArrow = XmCreateArrowButton(eventCtrlForm, "upArrow", args, ac);
XtAddCallback(upArrow, XmNactivateCallback,
(XtCallbackProc) nextEvtCB, window);
XtManageChild(upArrow);
ac = 0;
sprintf(ctmp," %d ", ac);
XtSetArg(args[ac], XmNlabelString, (s1=MKSTRING(ctmp))); ac++;
XtSetArg(args[ac], XmNcolumns, 7); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNleftWidget, upArrow); ac++;
eventNumText = (Widget) XmCreateLabelGadget(
eventCtrlForm, "eventNumText",
args, ac);
/* eventNumText = XmCreateText(eventCtrlForm, "eventNumText", args, ac); */
XtManageChild(eventNumText);
ac = 0;
XtSetArg(args[ac], XmNarrowDirection, XmARROW_DOWN); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNleftWidget, eventNumText); ac++;
downArrow = XmCreateArrowButton(eventCtrlForm, "downArrow", args, ac);
XtAddCallback(downArrow, XmNactivateCallback,
(XtCallbackProc) previousEvtCB, window);
XtManageChild(downArrow);
ac = 0;
XtSetArg(args[ac], XmNlabelString, (s1=MKSTRING(eventBarText))); ac++;
XtSetArg(args[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
eventCtrlText = (Widget) XmCreateLabelGadget(
eventCtrlForm, "eventCtrlText",
args, ac);
XmStringFree(s1);
XtManageChild(eventCtrlText);
}
/* Create a Form for the controls along the left edge of window */
ac = 0;
if (hasEventBar) {
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNtopWidget, eventCtrlFrame); ac++;
} else {
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
}
controls = XmCreateForm(form, "controls", args, ac);
XtManageChild(controls);
ac = 0;
XtSetArg(args[ac], XmNborderWidth, (Dimension)0); ac++;
XtSetArg(args[ac], XmNpacking, XmPACK_COLUMN); ac++;
XtSetArg(args[ac], XmNspacing, 0); ac++;
XtSetArg(args[ac], XmNnumColumns, (short)2); ac++;
stability = XmCreateRowColumn(controls, "stability", args, ac);
XtManageChild(stability);
ac = 0;
XtSetArg(args[ac], XmNlabelString, (s1=MKSTRING("Particle Types"))); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNtopWidget, stability); ac++;
particleTypeLabel = (Widget) XmCreateLabelGadget(
controls, "particleTypeLabel",
args, ac);
XmStringFree(s1);
XtManageChild(particleTypeLabel);
ac = 0;
XtSetArg(args[ac], XmNborderWidth, (Dimension)0); ac++;
XtSetArg(args[ac], XmNpacking, XmPACK_COLUMN); ac++;
XtSetArg(args[ac], XmNspacing, 0); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNnumColumns, (short)2); ac++;
XtSetArg(args[ac], XmNtopWidget, particleTypeLabel); ac++;
particleType = XmCreateRowColumn(controls, "particleType", args, ac);
XtManageChild(particleType);
ac = 0;
XtSetArg(args[ac], XmNhighlightThickness, 0); ac++;
XtSetArg(args[ac], XmNpacking, XmPACK_COLUMN); ac++;
XtSetArg(args[ac], XmNspacing, 0); ac++;
XtSetArg(args[ac], XmNorientation, XmHORIZONTAL); ac++;
if (hasEventBar) {
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNtopWidget, eventCtrlFrame); ac++;
} else {
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
}
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNleftWidget, controls); ac++;
XtSetArg(args[ac], XmNtopOffset, (int)2); ac++;
XtSetArg(args[ac], XmNleftOffset, (int)0); ac++;
stats = XmCreateRowColumn(form, "stats", args, ac);
XtManageChild(stats);
#define TOGGLE_BTN(parent, label, name, cb, set) \
ac = 0; \
XtSetArg(args[ac], XmNlabelString, (s1=MKSTRING(label))); ac++; \
XtSetArg(args[ac], XmNset, set); ac++; \
XtSetArg(args[ac], XmNmarginHeight, 0); ac++; \
widget = XmCreateToggleButtonGadget(parent, name, args, ac); \
XmStringFree(s1); \
XtAddCallback(widget, XmNvalueChangedCallback, \
(XtCallbackProc) cb, window); \
XtManageChild(widget); \
TOGGLE_BTN(stability, "Stable", "stable", stableCB, True);
TOGGLE_BTN(stability, "Unstable", "unstable", unstableCB, True);
TOGGLE_BTN(particleType, "Charged", "charged", chargedCB, True);
TOGGLE_BTN(particleType, "Neutral", "neutral", neutralCB, True);
TOGGLE_BTN(particleType, "Electrons", "electrons", electronsCB, True);
TOGGLE_BTN(particleType, "Muons", "muons", muonsCB, True);
TOGGLE_BTN(particleType, "Neutrinos", "neutrinos", neutrinosCB, True);
TOGGLE_BTN(particleType, "Gammas", "gammas", gammasCB, True);
TOGGLE_BTN(particleType, "Quarks/Gluons", "quarks", quarksCB, True);
TOGGLE_BTN(particleType,"Hadrons", "hadrons", hadronsCB, True);
TOGGLE_BTN(particleType,"W/Z", "wz", wzCB, True);
/* Do now the slider.. X, Y ,Z translation first. */
ac = 0;
XtSetArg(args[ac], XmNborderWidth, (Dimension)0); ac++;
XtSetArg(args[ac], XmNpacking, XmPACK_COLUMN); ac++;
XtSetArg(args[ac], XmNspacing, 0); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
/* XtSetArg(args[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++; */
XtSetArg(args[ac], XmNnumColumns, (short)1); ac++;
XtSetArg(args[ac], XmNtopWidget, particleType); ac++;
/* XtSetArg(args[ac], XmNrightWidget, particleType); ac++; */
allSliders = XmCreateRowColumn(controls, "allSliders", args, ac);
XtManageChild(allSliders);
ac = 0;
XtSetArg(args[ac], XmNpacking, XmPACK_COLUMN); ac++;
XtSetArg(args[ac], XmNadjustLast, False); ac++;
XtSetArg(args[ac], XmNspacing, 0); ac++;
XtSetArg(args[ac], XmNnumColumns, (short)5); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNtopWidget, allSliders); ac++;
rotation = XmCreateRowColumn(controls, "rotation", args, ac);
XtManageChild(rotation);
/* Get foreground an background colors for pixmap buttons */
ac = 0;
XtSetArg(args[ac], XmNforeground, &foreground); ac++;
XtSetArg(args[ac], XmNbackground, &background); ac++;
XtGetValues(controls, args, ac);
#define ROTATE_BTN(pmName, widgetName, cb) \
pm = XmGetPixmap(XtScreen(parent), pmName, foreground, background); \
ac = 0; \
XtSetArg(args[ac], XmNlabelType, XmPIXMAP); ac++; \
XtSetArg(args[ac], XmNlabelPixmap, pm); ac++; \
widget = XmCreatePushButtonGadget(rotation, widgetName, args, ac); \
XtAddCallback(widget, XmNactivateCallback, \
(XtCallbackProc) cb, window); \
XtManageChild(widget);
ROTATE_BTN("viewRotXPos", "viewRotXPos", viewRotXPosCB)
ROTATE_BTN("viewRotYPos", "viewRotYPos", viewRotYPosCB)
ROTATE_BTN("viewRotZPos", "viewRotZPos", viewRotZPosCB)
ROTATE_BTN("viewRotXNeg", "viewRotXNeg", viewRotXNegCB)
ROTATE_BTN("viewRotYNeg", "viewRotYNeg", viewRotYNegCB)
ROTATE_BTN("viewRotZNeg", "viewRotZNeg", viewRotZNegCB)
ROTATE_BTN("coordRotXPos", "coordRotXPos", coordRotXPosCB)
ROTATE_BTN("coordRotYPos", "coordRotYPos", coordRotYPosCB)
ROTATE_BTN("coordRotZPos", "coordRotZPos", coordRotZPosCB)
ROTATE_BTN("coordRotXNeg", "coordRotXNeg", coordRotXNegCB)
ROTATE_BTN("coordRotYNeg", "coordRotYNeg", coordRotYNegCB)
ROTATE_BTN("coordRotZNeg", "coordRotZNeg", coordRotZNegCB)
ROTATE_BTN("scaleUp", "scaleUp", scaleUpCB)
ROTATE_BTN("scaleDown", "scaleDown", scaleDownCB)
ROTATE_BTN("resetRotation", "resetRotation", resetRotationCB)
ac = 0;
XtSetArg(args[ac], XmNshadowType, XmSHADOW_IN); ac++;
XtSetArg(args[ac], XmNshadowThickness, 1); ac++;
scaleFrame = XmCreateFrame(stats, "scaleFrame", args, ac);
XtManageChild(scaleFrame);
trackInfoFrame = XmCreateFrame(stats, "trackInfoFrame", args, ac);
XtManageChild(trackInfoFrame);
ac = 0;
XtSetArg(args[ac], XmNpacking, XmPACK_COLUMN); ac++;
XtSetArg(args[ac], XmNentryAlignment, XmALIGNMENT_CENTER); ac++;
XtSetArg(args[ac], XmNspacing, 0); ac++;
scaleRC = XmCreateRowColumn(scaleFrame, "scaleRC", args, ac);
XtManageChild(scaleRC);
ac = 0;
scaleArea = XmCreateDrawingArea(scaleRC, "scaleArea", args, ac);
XtAddCallback(scaleArea, XmNexposeCallback,
(XtCallbackProc) scaleExposeCB, window);
XtManageChild(scaleArea);
ac = 0;
XtSetArg(args[ac], XmNlabelString, (s1=MKSTRING("x"))); ac++;
XtSetArg(args[ac], XmNmarginHeight, 0); ac++;
scaleLabel = (Widget) XmCreateLabelGadget(
scaleRC, "scaleLabel", args, ac);
XmStringFree(s1);
XtManageChild(scaleLabel);
ac = 0;
XtSetArg(args[ac], XmNalignment, XmALIGNMENT_BEGINNING); ac++;
XtSetArg(args[ac], XmNrecomputeSize, False); ac++;
XtSetArg(args[ac], XmNlabelString, (s1=MKSTRING(
"00000 tracks, 00000 are stable\nx\nTrack of max. xxxxx is a(n) xxxx"))); ac++;
trackInfo = (Widget) XmCreateLabelGadget(
trackInfoFrame, "trackInfo", args, ac);
XmStringFree(s1);
XtManageChild(trackInfo);
ac = 0;
XtSetArg(args[ac], XmNshowAxes, True); ac++;
XtSetArg(args[ac], XmNperspectiveOn, True); ac++;
XtSetArg(args[ac], XmNdoubleBuffer, False); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNleftWidget, controls); ac++;
XtSetArg(args[ac], XmNtopWidget, stats); ac++;
XtSetArg(args[ac], XmNtopOffset, (int)0); ac++;
XtSetArg(args[ac], XmNbottomOffset, (int)0); ac++;
XtSetArg(args[ac], XmNleftOffset, (int)0); ac++;
XtSetArg(args[ac], XmNrightOffset, (int)0); ac++;
spin = XtCreateManagedWidget("spin", spinWidgetClass, form, args, ac);
XtAddCallback(spin, XmNresizeCallback,
(XtCallbackProc) resizeCB, window);
XtAddCallback(spin, XmNredisplayCallback,
(XtCallbackProc) redisplayCB, window);
XtAddCallback(spin, XmNbtn2Callback,
(XtCallbackProc) spinSelectCB, window);
/* Place now the Sliders, right attached to the spin widget */
formt1 = createSpaceSlider(&window->scaleSliderScale,
&window->scaleSliderValue,
allSliders, spin,
"scaleScale", "Overall Scale",
SLIDER_MAX, window, scaleCB);
formt1 = createSpaceSlider(&window->xTranslSliderScale,
&window->xTranslSliderValue,
allSliders, spin,
"scaleX", "X transl.",
(SLIDER_MAX/2), window, xTransCB);
formt1 = createSpaceSlider(&window->yTranslSliderScale,
&window->yTranslSliderValue,
allSliders, spin,
"scaleY", "Y transl.",
(SLIDER_MAX/2), window, yTransCB);
formt1 = createSpaceSlider(&window->zTranslSliderScale,
&window->zTranslSliderValue,
allSliders, spin,
"scaleZ", "Z transl.",
(SLIDER_MAX/2), window, zTransCB);
formt1 = createSpaceSlider(&window->momToSpaceSliderScale,
&window->momToSpaceSliderValue,
allSliders, spin,
"momtospace", "P to Dist",
(SLIDER_MAX/10), window, momToSpaceCB);
formt1 = createSpaceSlider(&window->longToTrSliderScale,
&window->longToTrSliderValue,
allSliders, spin,
"LongToTr",
"Aspect ratio Long/Tr. ",
(SLIDER_MAX/10), window, longToTrCB);
/* This last string is in fact constraining the appearance of the widget */
window->spin = spin;
window->eventNumText = eventNumText;
window->eventSelectorLabel = eventCtrlText;
window->statsLabel = trackInfo;
window->scaleArea = scaleArea;
window->scaleLabel = scaleLabel;
window->stable = True;
window->unstable = True;
window->charged = True;
window->neutral = True;
window->electrons = True;
window->muons = True;
window->gammas = True;
window->neutrinos = True;
window->quarks = True;
window->hadrons = True;
window->wz = True;
return(form);
}
int open_ants(Widget w, char *fn, char *cmd)
{
Widget list;
Arg wargs[10];
XmString *xmstr;
char *p;
string stmp, buf, user;
int i, n, nindx, df, rec=0, bl_len;
int err;
size_t size;
FILE *pdf;
static ANTS ants;
void send_line();
char *getScanStr();
strcpy(dfilname, fn);
strcpy(stmp, fn);
p = strtok(stmp, "/");
while (p) {
strcpy(buf, p);
p = strtok(NULL, "/");
}
sscanf(buf, "DF%2d%4d.%s", &df, &bl_len, user);
if (bl_len == 0) bl_len = 3;
pdf = OpenDfil(df, bl_len, user, dfilname);
if (!pdf) {
sprintf(buf, "Open POPS file: cannot open dfile %s.", dfilname);
send_line(buf);
return 1;
}
nindx = ReadDfilIndex(pdf, indx);
if (nindx <= 0) {
if (nindx == 0) {
sprintf(buf, "Open POPS file: dfile %s is empty.", dfilname);
} else {
sprintf(buf, "Open POPS file: dfile %s is corrupt.", dfilname);
}
send_line(buf);
fclose(pdf);
return 1;
}
i = 0;
while (i < 500 && indx[i] != 0) {
i++;
}
nindx = i;
sprintf(buf, "POPS dfile %s (%d scans) is opened.", dfilname, nindx);
send_line(buf);
size = (size_t)(bl_len*DFILBLOCK)*sizeof(DFWORD);
if (!itwh)
itwh = (DFWORD *)malloc(size);
else
itwh = (DFWORD *)realloc(itwh, size);
if (!itwh) {
sprintf(buf, "Open POPS -- can't allocate itwh[%d]",
bl_len*DFILBLOCK);
send_line(buf);
fclose(pdf);
return 1;
}
strcpy(type_of_seq, cmd);
if (strcmp(cmd, "mapants2") == 0 ||
strcmp(cmd, "ants2") == 0 ||
strcmp(cmd, "seqants2") == 0 ||
strcmp(cmd, "appmapants2") == 0 ||
strcmp(cmd, "appseqants2") == 0)
rec = 1;
ants.pdf = pdf;
ants.bl_len = bl_len;
ants.df = df;
ants.rec = rec;
ants.fname = dfilname;
ants.nscans = nindx;
xmstr = (XmString *) XtMalloc(nindx * sizeof(XmString));
if (!xmstr) {
sprintf(buf, "Open POPS -- can't allocate xmstr[%d]", nindx);
send_line(buf);
fclose(pdf);
return 1;
}
for (i=0; i<nindx; i++) {
err = GetDfilBlock(pdf, i+1, bl_len, itwh);
if (err != 0) {
sprintf(buf, "Open POPS -- can't read read block %d", i+1);
send_line(buf);
fclose(pdf);
return ret_open_ants(xmstr, nindx, err);
}
filltwh(&OnScan, &XScan, rec);
OnScan.Slength = HEADER + 2*OnScan.NChannel;
xmstr[i] = MKSTRING(getScanStr(i));
}
n = 0;
if (nindx > 0) {
XtSetArg(wargs[n], XmNitemCount, nindx); n++;
XtSetArg(wargs[n], XmNitems, xmstr); n++;
if (nindx <= 30) {
XtSetArg(wargs[n], XmNvisibleItemCount, nindx); n++;
} else {
XtSetArg(wargs[n], XmNvisibleItemCount, 30); n++;
}
}
XtSetArg(wargs[n], XmNfontList, gp->flist10); n++;
if (strncmp(cmd, "mapants", 7)==0 ||
strncmp(cmd, "seqants", 7)==0 ||
strncmp(cmd, "appmapants", 10)==0 ||
strncmp(cmd, "appseqants", 10)==0) {
XtSetArg(wargs[n], XmNselectionPolicy, XmEXTENDED_SELECT); n++;
}
list = create_list_dialog(w, dfilname, &ants, wargs, n);
if (strncmp(cmd, "mapants", 7)==0 ||
strncmp(cmd, "seqants", 7)==0 ||
strncmp(cmd, "appmapants", 10)==0 ||
strncmp(cmd, "appseqants", 10)==0) {
XtAddCallback(list, XmNextendedSelectionCallback,
(XtCallbackProc)selectCB, &ants);
XtAddCallback(list, XmNmultipleSelectionCallback,
(XtCallbackProc)selectCB, &ants);
} else
XtAddCallback(list, XmNbrowseSelectionCallback,
(XtCallbackProc)selectCB, &ants);
return ret_open_ants(xmstr, nindx, 0);
}
/*
** Create a dialog for the output of a shell command. The dialog lives until
** the user presses the Dismiss button, and is then destroyed
*/
static void createOutputDialog(Widget parent, char *text)
{
Arg al[50];
int ac, rows, cols, hasScrollBar, wrapped;
Widget form, textW, button;
XmString st1;
/* measure the width and height of the text to determine size for dialog */
measureText(text, MAX_OUT_DIALOG_COLS, &rows, &cols, &wrapped);
if (rows > MAX_OUT_DIALOG_ROWS) {
rows = MAX_OUT_DIALOG_ROWS;
hasScrollBar = True;
} else
hasScrollBar = False;
if (cols > MAX_OUT_DIALOG_COLS)
cols = MAX_OUT_DIALOG_COLS;
if (cols == 0)
cols = 1;
/* Without completely emulating Motif's wrapping algorithm, we can't
be sure that we haven't underestimated the number of lines in case
a line has wrapped, so let's assume that some lines could be obscured
*/
if (wrapped)
hasScrollBar = True;
ac = 0;
form = CreateFormDialog(parent, "shellOutForm", al, ac);
ac = 0;
XtSetArg(al[ac], XmNlabelString, st1=MKSTRING("OK")); ac++;
XtSetArg(al[ac], XmNmarginWidth, BUTTON_WIDTH_MARGIN); ac++;
XtSetArg(al[ac], XmNhighlightThickness, 0); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_NONE); ac++;
button = XmCreatePushButtonGadget(form, "ok", al, ac);
XtManageChild(button);
XtVaSetValues(form, XmNdefaultButton, button, NULL);
XtVaSetValues(form, XmNcancelButton, button, NULL);
XmStringFree(st1);
XtAddCallback(button, XmNactivateCallback, destroyOutDialogCB,
XtParent(form));
ac = 0;
XtSetArg(al[ac], XmNrows, rows); ac++;
XtSetArg(al[ac], XmNcolumns, cols); ac++;
XtSetArg(al[ac], XmNresizeHeight, False); ac++;
XtSetArg(al[ac], XmNtraversalOn, False); ac++;
XtSetArg(al[ac], XmNwordWrap, True); ac++;
XtSetArg(al[ac], XmNscrollHorizontal, False); ac++;
XtSetArg(al[ac], XmNscrollVertical, hasScrollBar); ac++;
XtSetArg(al[ac], XmNhighlightThickness, 0); ac++;
XtSetArg(al[ac], XmNspacing, 0); ac++;
XtSetArg(al[ac], XmNeditMode, XmMULTI_LINE_EDIT); ac++;
XtSetArg(al[ac], XmNeditable, False); ac++;
XtSetArg(al[ac], XmNvalue, text); ac++;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNbottomWidget, button); ac++;
textW = XmCreateScrolledText(form, "outText", al, ac);
AddMouseWheelSupport(textW);
XtManageChild(textW);
XtVaSetValues(XtParent(form), XmNtitle, "Output from Command", NULL);
ManageDialogCenteredOnPointer(form);
}
int
main(int argc,char *argv[])
{
int arg,ret=KEYSERVER_INTERNAL_ERROR,try_srv=1;
char line[MAX_LINE];
int failed=0;
struct keylist *keylist=NULL,*keyptr=NULL;
char *proxy=NULL;
struct curl_slist *headers=NULL;
console=stderr;
/* Kludge to implement standard GNU options. */
if (argc > 1 && !strcmp (argv[1], "--version"))
{
printf ("gpgkeys_hkp (GnuPG) %s\n", VERSION);
printf ("Uses: %s\n", curl_version());
return 0;
}
else if (argc > 1 && !strcmp (argv[1], "--help"))
{
show_help (stdout);
return 0;
}
while((arg=getopt(argc,argv,"hVo:"))!=-1)
switch(arg)
{
default:
case 'h':
show_help (console);
return KEYSERVER_OK;
case 'V':
fprintf(stdout,"%d\n%s\n",KEYSERVER_PROTO_VERSION,VERSION);
return KEYSERVER_OK;
case 'o':
output=fopen(optarg,"w");
if(output==NULL)
{
fprintf(console,"gpgkeys: Cannot open output file `%s': %s\n",
optarg,strerror(errno));
return KEYSERVER_INTERNAL_ERROR;
}
break;
}
if(argc>optind)
{
input=fopen(argv[optind],"r");
if(input==NULL)
{
fprintf(console,"gpgkeys: Cannot open input file `%s': %s\n",
argv[optind],strerror(errno));
return KEYSERVER_INTERNAL_ERROR;
}
}
if(input==NULL)
input=stdin;
if(output==NULL)
output=stdout;
opt=init_ks_options();
if(!opt)
return KEYSERVER_NO_MEMORY;
/* Get the command and info block */
while(fgets(line,MAX_LINE,input)!=NULL)
{
int err;
char option[MAX_OPTION+1];
if(line[0]=='\n')
break;
err=parse_ks_options(line,opt);
if(err>0)
{
ret=err;
goto fail;
}
else if(err==0)
continue;
if(sscanf(line,"OPTION %" MKSTRING(MAX_OPTION) "s\n",option)==1)
{
int no=0;
char *start=&option[0];
option[MAX_OPTION]='\0';
if(ascii_strncasecmp(option,"no-",3)==0)
{
no=1;
start=&option[3];
}
if(ascii_strncasecmp(start,"http-proxy",10)==0)
{
if(no)
{
free(proxy);
proxy=strdup("");
}
else if(start[10]=='=')
{
if(strlen(&start[11])<MAX_PROXY)
{
free(proxy);
proxy=strdup(&start[11]);
}
}
}
else if(ascii_strcasecmp(start,"try-dns-srv")==0)
{
if(no)
try_srv=0;
else
try_srv=1;
}
continue;
}
}
if(!opt->scheme)
{
fprintf(console,"gpgkeys: no scheme supplied!\n");
ret=KEYSERVER_SCHEME_NOT_FOUND;
goto fail;
}
if(ascii_strcasecmp(opt->scheme,"hkps")==0)
{
proto="https";
port="443";
}
else
{
proto="http";
port="11371";
}
if(!opt->host)
{
fprintf(console,"gpgkeys: no keyserver host provided\n");
goto fail;
}
if(opt->timeout && register_timeout()==-1)
{
fprintf(console,"gpgkeys: unable to register timeout handler\n");
return KEYSERVER_INTERNAL_ERROR;
}
curl_global_init(CURL_GLOBAL_DEFAULT);
curl=curl_easy_init();
if(!curl)
{
fprintf(console,"gpgkeys: unable to initialize curl\n");
ret=KEYSERVER_INTERNAL_ERROR;
goto fail;
}
/* If the user gives a :port, then disable SRV. The semantics of a
specified port and SRV do not play well together. */
if(opt->port)
port=opt->port;
else if(try_srv)
{
char *srvtag;
if(ascii_strcasecmp(opt->scheme,"hkp")==0)
srvtag="pgpkey-http";
else if(ascii_strcasecmp(opt->scheme,"hkps")==0)
srvtag="pgpkey-https";
else
srvtag=NULL;
#ifdef HAVE_LIBCURL
/* We're using libcurl, so fake SRV support via our wrapper.
This isn't as good as true SRV support, as we do not try all
possible targets at one particular level and work our way
down the list, but it's better than nothing. */
srv_replace(srvtag);
#else
/* We're using our internal curl shim, so we can use its (true)
SRV support. Obviously, CURLOPT_SRVTAG_GPG_HACK isn't a real
libcurl option. It's specific to our shim. */
curl_easy_setopt(curl,CURLOPT_SRVTAG_GPG_HACK,srvtag);
#endif
}
curl_easy_setopt(curl,CURLOPT_ERRORBUFFER,errorbuffer);
if(opt->auth)
curl_easy_setopt(curl,CURLOPT_USERPWD,opt->auth);
if(opt->debug)
{
fprintf(console,"gpgkeys: curl version = %s\n",curl_version());
curl_easy_setopt(curl,CURLOPT_STDERR,console);
curl_easy_setopt(curl,CURLOPT_VERBOSE,1L);
}
curl_easy_setopt(curl,CURLOPT_SSL_VERIFYPEER,(long)opt->flags.check_cert);
curl_easy_setopt(curl,CURLOPT_CAINFO,opt->ca_cert_file);
/* Avoid caches to get the most recent copy of the key. This is bug
#1061. In pre-curl versions of the code, we didn't do it. Then
we did do it (as a curl default) until curl changed the default.
Now we're doing it again, but in such a way that changing
defaults in the future won't impact us. We set both the Pragma
and Cache-Control versions of the header, so we're good with both
HTTP 1.0 and 1.1. */
headers=curl_slist_append(headers,"Pragma: no-cache");
if(headers)
headers=curl_slist_append(headers,"Cache-Control: no-cache");
if(!headers)
{
fprintf(console,"gpgkeys: out of memory when building HTTP headers\n");
ret=KEYSERVER_NO_MEMORY;
goto fail;
}
curl_easy_setopt(curl,CURLOPT_HTTPHEADER,headers);
if(proxy)
curl_easy_setopt(curl,CURLOPT_PROXY,proxy);
/* If it's a GET or a SEARCH, the next thing to come in is the
keyids. If it's a SEND, then there are no keyids. */
if(opt->action==KS_SEND)
while(fgets(line,MAX_LINE,input)!=NULL && line[0]!='\n');
else if(opt->action==KS_GET
|| opt->action==KS_GETNAME || opt->action==KS_SEARCH)
{
for(;;)
{
struct keylist *work;
if(fgets(line,MAX_LINE,input)==NULL)
break;
else
{
if(line[0]=='\n' || line[0]=='\0')
break;
work=xtrymalloc(sizeof(struct keylist));
if(work==NULL)
{
fprintf(console,"gpgkeys: out of memory while "
"building key list\n");
ret=KEYSERVER_NO_MEMORY;
goto fail;
}
strcpy(work->str,line);
/* Trim the trailing \n */
work->str[strlen(line)-1]='\0';
work->next=NULL;
/* Always attach at the end to keep the list in proper
order for searching */
if(keylist==NULL)
keylist=work;
else
keyptr->next=work;
keyptr=work;
}
}
}
else
{
fprintf(console,"gpgkeys: no keyserver command specified\n");
goto fail;
}
/* Send the response */
fprintf(output,"VERSION %d\n",KEYSERVER_PROTO_VERSION);
fprintf(output,"PROGRAM %s %s\n\n",VERSION,curl_version());
if(opt->verbose>1)
{
fprintf(console,"Host:\t\t%s\n",opt->host);
if(opt->port)
fprintf(console,"Port:\t\t%s\n",opt->port);
if(strcmp(opt->path,"/")!=0)
fprintf(console,"Path:\t\t%s\n",opt->path);
fprintf(console,"Command:\t%s\n",ks_action_to_string(opt->action));
}
if(opt->action==KS_GET)
{
keyptr=keylist;
while(keyptr!=NULL)
{
set_timeout(opt->timeout);
if(get_key(keyptr->str)!=KEYSERVER_OK)
failed++;
keyptr=keyptr->next;
}
}
else if(opt->action==KS_GETNAME)
{
keyptr=keylist;
while(keyptr!=NULL)
{
set_timeout(opt->timeout);
if(get_name(keyptr->str)!=KEYSERVER_OK)
failed++;
keyptr=keyptr->next;
}
}
else if(opt->action==KS_SEND)
{
int eof=0;
do
{
set_timeout(opt->timeout);
if(send_key(&eof)!=KEYSERVER_OK)
failed++;
}
while(!eof);
}
else if(opt->action==KS_SEARCH)
{
char *searchkey=NULL;
int len=0;
set_timeout(opt->timeout);
/* To search, we stick a space in between each key to search
for. */
keyptr=keylist;
while(keyptr!=NULL)
{
len+=strlen(keyptr->str)+1;
keyptr=keyptr->next;
}
searchkey=xtrymalloc(len+1);
if(searchkey==NULL)
{
ret=KEYSERVER_NO_MEMORY;
fail_all(keylist,KEYSERVER_NO_MEMORY);
goto fail;
}
searchkey[0]='\0';
keyptr=keylist;
while(keyptr!=NULL)
{
strcat(searchkey,keyptr->str);
strcat(searchkey," ");
keyptr=keyptr->next;
}
/* Nail that last space */
if(*searchkey)
searchkey[strlen(searchkey)-1]='\0';
if(search_key(searchkey)!=KEYSERVER_OK)
failed++;
free(searchkey);
}
else
abort();
if(!failed)
ret=KEYSERVER_OK;
fail:
while(keylist!=NULL)
{
struct keylist *current=keylist;
keylist=keylist->next;
free(current);
}
if(input!=stdin)
fclose(input);
if(output!=stdout)
fclose(output);
free_ks_options(opt);
curl_slist_free_all(headers);
if(curl)
curl_easy_cleanup(curl);
free(proxy);
return ret;
}
void DrawScale(StdHepWindow *window)
{
Widget scaleWidget = window->scaleArea;
Window scaleWindow = XtWindow(scaleWidget);
Display *display = XtDisplay(scaleWidget);
double scale, scaleAreaWidth, scaleBarLength = 1., barMultiplier = 2.;
double tempMom;
short widgetWidth, spinWidth, widgetHeight;
int leftX, rightX, topY, midY, bottomY;
GC gc = window->scaleGC;
char scaleText[100];
XmString cScaleText;
SpaceWindow *wins;
double scaleVertex;
PhaseWindow *winp;
ParaWindow *winpa;
/* Get the scale factor for translating spin coordinates to pixels */
GET_ONE_RSRC(window->spin, XmNwidth, &spinWidth);
scale = (1./(SpinGetScale(window->spin)/2.)) / (double)spinWidth;
/* Calculate the width of the scale draw area in spin coordinates */
GET_ONE_RSRC(scaleWidget, XmNwidth, &widgetWidth);
scaleAreaWidth = widgetWidth * scale;
/* choose a sensible length for the scale bar, such as 1, 5, 10, 50 etc. */
if (scaleAreaWidth < 1.) {
while (scaleBarLength > scaleAreaWidth) {
scaleBarLength /= barMultiplier;
barMultiplier = (barMultiplier == 2.) ? 5. : 2.;
}
} else {
while (scaleBarLength < scaleAreaWidth) {
barMultiplier = (barMultiplier == 2.) ? 5. : 2.;
scaleBarLength *= barMultiplier;
}
scaleBarLength /= barMultiplier;
}
/* draw the scale bar in the middle of the scale area widget */
GET_ONE_RSRC(scaleWidget, XmNheight, &widgetHeight);
leftX = ((scaleAreaWidth - scaleBarLength) / 2.) / scale;
rightX = leftX + scaleBarLength / scale;
topY = widgetHeight/4;
midY = widgetHeight/2;
bottomY = midY + widgetHeight/4;
XClearWindow(display, scaleWindow);
XDrawLine(display, scaleWindow, gc, leftX, topY, leftX, bottomY);
XDrawLine(display, scaleWindow, gc, rightX, topY, rightX, bottomY);
XDrawLine(display, scaleWindow, gc, leftX, midY, rightX, midY);
/* put in the text to label the scale */
if (window->type == STDHEP_PHASE) {
winp = (PhaseWindow *) window;
if (winp->displayMode == BY_MOMENTUM || winp->displayMode == BY_PT)
sprintf(scaleText, "%G Gev/c", scaleBarLength);
else
sprintf(scaleText, "%G Unit Eta", scaleBarLength);
} else if (window->type == STDHEP_PARA) {
winpa = (ParaWindow *) window;
scaleVertex = scaleBarLength / winpa->currentRapToPt;
sprintf (scaleText, "%G eta = %G Gev/c",scaleBarLength, scaleVertex);
} else {
wins = (SpaceWindow *) window;
tempMom = wins->currentMomToSpace;
if( tempMom == 0.0) tempMom = EPSILON;
scaleVertex = scaleBarLength / tempMom;
sprintf (scaleText, "%G cm = %G Gev/c",scaleBarLength, scaleVertex);
}
cScaleText = MKSTRING(scaleText);
SET_ONE_RSRC(window->scaleLabel, XmNlabelString, cScaleText);
XmStringFree(cScaleText);
}
