#define LIST(receiver) (ENTITY(receiver, ListIterator)->list)
#define HEAD(receiver) (ENTITY(receiver, List)->head)
#define TAIL(receiver) (ENTITY(receiver, List)->tail)
#define ITERATOR(receiver) (ENTITY(receiver, List)->iterator)
#define List_GID 0x42
DefaultOperations(List);
Action(List, SystemIterator);
DefaultInit(List,
HEAD(receiver) = ListNode_Create();
TAIL(receiver) = ListNode_Create();
PREV(TAIL(receiver)) = HEAD(receiver);
NEXT(HEAD(receiver)) = TAIL(receiver);
PREV(HEAD(receiver)) = NEXT(TAIL(receiver)) = nothing;
ITERATOR(receiver) = List_SystemIterator(receiver);
)
DefaultCreator(List);
Action(List, Destroy)
{
Object node = HEAD(receiver);
do {
Object nextNode = NEXT(node);
Object_Release(node);
int src_v4l2_set_input(src_t *src)
{
src_v4l2_t *s = (src_v4l2_t *) src->state;
struct v4l2_input input;
int count = 0, i = -1;
memset(&input, 0, sizeof(input));
if(src->list & SRC_LIST_INPUTS)
{
HEAD("--- Available inputs:");
input.index = count;
while(!ioctl(s->fd, VIDIOC_ENUMINPUT, &input))
{
MSG("%i: %s", count, input.name);
input.index = ++count;
}
}
/* If no input was specified, use input 0. */
if(!src->input)
{
MSG("No input was specified, using the first.");
count = 1;
i = 0;
}
/* Check if the input is specified by name. */
if(i == -1)
{
input.index = count;
while(!ioctl(s->fd, VIDIOC_ENUMINPUT, &input))
{
if(!strncasecmp((char *) input.name, src->input, 32))
i = count;
input.index = ++count;
}
}
if(i == -1)
{
char *endptr;
/* Is the input specified by number? */
i = strtol(src->input, &endptr, 10);
if(endptr == src->input) i = -1;
}
if(i == -1 || i >= count)
{
/* The specified input wasn't found! */
ERROR("Unrecognised input \"%s\"", src->input);
return(-1);
}
/* Set the input. */
input.index = i;
if(ioctl(s->fd, VIDIOC_ENUMINPUT, &input) == -1)
{
ERROR("Unable to query input %i.", i);
ERROR("VIDIOC_ENUMINPUT: %s", strerror(errno));
return(-1);
}
DEBUG("%s: Input %i information:", src->source, i);
DEBUG("name = \"%s\"", input.name);
DEBUG("type = %08X", input.type);
if(input.type & V4L2_INPUT_TYPE_TUNER) DEBUG("- TUNER");
if(input.type & V4L2_INPUT_TYPE_CAMERA) DEBUG("- CAMERA");
DEBUG("audioset = %08X", input.audioset);
DEBUG("tuner = %08X", input.tuner);
DEBUG("status = %08X", input.status);
if(input.status & V4L2_IN_ST_NO_POWER) DEBUG("- NO_POWER");
if(input.status & V4L2_IN_ST_NO_SIGNAL) DEBUG("- NO_SIGNAL");
if(input.status & V4L2_IN_ST_NO_COLOR) DEBUG("- NO_COLOR");
if(input.status & V4L2_IN_ST_NO_H_LOCK) DEBUG("- NO_H_LOCK");
if(input.status & V4L2_IN_ST_COLOR_KILL) DEBUG("- COLOR_KILL");
if(input.status & V4L2_IN_ST_NO_SYNC) DEBUG("- NO_SYNC");
if(input.status & V4L2_IN_ST_NO_EQU) DEBUG("- NO_EQU");
if(input.status & V4L2_IN_ST_NO_CARRIER) DEBUG("- NO_CARRIER");
if(input.status & V4L2_IN_ST_MACROVISION) DEBUG("- MACROVISION");
if(input.status & V4L2_IN_ST_NO_ACCESS) DEBUG("- NO_ACCESS");
if(input.status & V4L2_IN_ST_VTR) DEBUG("- VTR");
if(ioctl(s->fd, VIDIOC_S_INPUT, &i) == -1)
{
ERROR("Error selecting input %i", i);
ERROR("VIDIOC_S_INPUT: %s", strerror(errno));
return(-1);
}
/* If this input is attached to a tuner, set the frequency. */
if(input.type & V4L2_INPUT_TYPE_TUNER)
{
char *range;
struct v4l2_tuner tuner;
struct v4l2_frequency freq;
/* Query the tuners capabilities. */
memset(&tuner, 0, sizeof(tuner));
tuner.index = input.tuner;
if(ioctl(s->fd, VIDIOC_G_TUNER, &tuner) == -1)
{
WARN("Error querying tuner %i.", input.tuner);
WARN("VIDIOC_G_TUNER: %s", strerror(errno));
return(0);
}
if(tuner.capability & V4L2_TUNER_CAP_LOW) range = "kHz";
else range = "MHz";
DEBUG("%s: Tuner %i information:", src->source, input.tuner);
DEBUG("name = \"%s\"", tuner.name);
DEBUG("type = %08X", tuner.type);
if(tuner.type == V4L2_TUNER_RADIO) DEBUG("- RADIO");
if(tuner.type == V4L2_TUNER_ANALOG_TV) DEBUG("- ANALOG_TV");
DEBUG("capability = %08X", tuner.capability);
if(tuner.capability & V4L2_TUNER_CAP_LOW) DEBUG("- LOW");
if(tuner.capability & V4L2_TUNER_CAP_NORM) DEBUG("- NORM");
if(tuner.capability & V4L2_TUNER_CAP_STEREO) DEBUG("- STEREO");
if(tuner.capability & V4L2_TUNER_CAP_LANG1) DEBUG("- LANG1");
if(tuner.capability & V4L2_TUNER_CAP_LANG2) DEBUG("- LANG2");
if(tuner.capability & V4L2_TUNER_CAP_SAP) DEBUG("- SAP");
DEBUG("rangelow = %08X, (%.3f%s)", tuner.rangelow, (double) tuner.rangelow * 16 / 1000, range);
DEBUG("rangehigh = %08X, (%.3f%s)", tuner.rangehigh, (double) tuner.rangehigh * 16 / 1000, range);
DEBUG("signal = %08X", tuner.signal);
DEBUG("afc = %08X", tuner.afc);
/* Set the frequency. */
memset(&freq, 0, sizeof(freq));
freq.tuner = input.tuner;
freq.type = V4L2_TUNER_ANALOG_TV;
freq.frequency = (src->frequency / 1000) * 16;
if(ioctl(s->fd, VIDIOC_S_FREQUENCY, &freq) == -1)
{
WARN("Error setting frequency %.3f%s", src->frequency / 16.0, range);
WARN("VIDIOC_S_FREQUENCY: %s", strerror(errno));
return(0);
}
MSG("Set frequency to %.3f%s",
(double) src->frequency / 1000, range);
}
return(0);
}
int fswc_grab(fswebcam_config_t *config)
{
int countImages=0;
while(1){
char* deviceName="/dev/video0";//strdup("/dev/video0")
uint32_t frame;
uint32_t x, y;
avgbmp_t *abitmap, *pbitmap;
gdImage *image, *original;
uint8_t modified;
src_t src;
/* Set source options... */
memset(&src, 0, sizeof(src));
src.input = config->input;
src.tuner = config->tuner;
src.frequency = config->frequency;
src.delay = config->delay;
src.timeout = 15; /* seconds */
src.use_read = config->use_read;
src.list = config->list;
src.palette = config->palette;
src.width = config->width;
src.height = config->height;
src.fps = config->fps;
src.option = config->option;
HEAD("--- Opening %s...%s", deviceName, config->device);
printf("--- Opening %s...%s", deviceName, config->device);
if(src_open(&src, deviceName) == -1) return(-1);
//if(src_open(&src, config->device) == -1) return(-1);
/* The source may have adjusted the width and height we passed
* to it. Update the main config to match. */
//
char countImageStr[20];
while(1){
countImages++;
/* Record the start time. */
config->start = time(NULL);
/* Allocate memory for the average bitmap buffer. */
/* Allocate memory for the average bitmap buffer. */
abitmap = calloc(config->width * config->height * 3, sizeof(avgbmp_t));
if(!abitmap)
{
ERROR("Out of memory.");
return(-1);
}
HEAD("--- Capturing frame...");
//if required timeout , break
if(src_grab(&src) != -1) {
/* Add frame to the average bitmap. */
fswc_add_image_jpeg(&src, abitmap);
}else{
break;
}
HEAD("--- Processing captured image...");
/* Copy the average bitmap image to a gdImage. */
original = gdImageCreateTrueColor(config->width, config->height);
printf("height is %d, width is %d------\n", config->height, config->width);
if(!original)
{
ERROR("Out of memory.");
free(abitmap);
return(-1);
}
pbitmap = abitmap;
for(y = 0; y < config->height; y++)
for(x = 0; x < config->width; x++)
{
int px = x;
int py = y;
int colour;
colour = (*(pbitmap++) / config->frames) << 16;
colour += (*(pbitmap++) / config->frames) << 8;
colour += (*(pbitmap++) / config->frames);
gdImageSetPixel(original, px, py, colour);
}
free(abitmap);
/* Make a copy of the original image. */
image = fswc_gdImageDuplicate(original);
if(!image)
{
ERROR("Out of memory.");
gdImageDestroy(image);
return(-1);
}
/* Run through the jobs list. */
snprintf(countImageStr, 20, "%d", countImages);
printf("countImageStr = %s\n", countImageStr);
//Generate the imgName
char imgName[50];
char imgScaleName[50];
bzero(imgName, 50);
bzero(imgScaleName, 50);
strcat(imgName, config->save);
//strcat(imgName, "img");
strcat(imgName, countImageStr);
strcat(imgName, ".jpg");
strcat(imgScaleName, "scaleImg");
strcat(imgScaleName, countImageStr);
strcat(imgScaleName, ".jpg");
//rotate the image
//image = fx_rotate(image, "180");
usleep(config->interval);
//save file, and scale
fswc_output(config, imgName, image);
//image = fx_scale(image, "256x192");
//fswc_output(config, imgScaleName, image);
gdImageDestroy(image);
gdImageDestroy(original);
}
/* We are now finished with the capture card. */
src_close(&src);
}
return(0);
}
struct pnode *add_symbol_constant(struct pnode *parms, int value)
{
return mk_list(HEAD(parms), mk_list(mk_constant(value), NULL));
}
/*
* FIXME: Deep (the whole tree) or shallow (just the top term) copy?
* The documentation never says, but the code as written below will
* make a deep copy. This should be documented.
*/
ETERM *erl_copy_term(const ETERM *ep)
{
int i;
ETERM *cp;
if (!ep) return NULL;
/* ASSERT(ep != NULL); */
cp = erl_alloc_eterm(ERL_TYPE(ep));
ERL_COUNT(cp) = 1;
switch(ERL_TYPE(cp)) {
case ERL_INTEGER:
case ERL_SMALL_BIG:
ERL_INT_VALUE(cp) = ERL_INT_VALUE(ep);
break;
case ERL_U_INTEGER:
case ERL_U_SMALL_BIG:
ERL_INT_UVALUE(cp) = ERL_INT_UVALUE(ep);
break;
case ERL_LONGLONG:
ERL_LL_VALUE(cp) = ERL_LL_VALUE(ep);
break;
case ERL_U_LONGLONG:
ERL_LL_UVALUE(cp) = ERL_LL_UVALUE(ep);
break;
case ERL_FLOAT:
ERL_FLOAT_VALUE(cp) = ERL_FLOAT_VALUE(ep);
break;
case ERL_ATOM:
if (!erl_atom_copy(&cp->uval.aval.d, &ep->uval.aval.d))
{
erl_free_term(cp);
erl_errno = ENOMEM;
return NULL;
}
break;
case ERL_PID:
/* FIXME: First copy the bit pattern, then duplicate the node
name and plug in. Somewhat ugly (also done with port and
ref below). */
memcpy(&cp->uval.pidval, &ep->uval.pidval, sizeof(Erl_Pid));
erl_atom_copy(&cp->uval.pidval.node, &ep->uval.pidval.node);
ERL_COUNT(cp) = 1;
break;
case ERL_PORT:
memcpy(&cp->uval.portval, &ep->uval.portval, sizeof(Erl_Port));
erl_atom_copy(&cp->uval.portval.node, &ep->uval.portval.node);
ERL_COUNT(cp) = 1;
break;
case ERL_REF:
memcpy(&cp->uval.refval, &ep->uval.refval, sizeof(Erl_Ref));
erl_atom_copy(&cp->uval.refval.node, &ep->uval.refval.node);
ERL_COUNT(cp) = 1;
break;
case ERL_LIST:
HEAD(cp) = erl_copy_term(HEAD(ep));
TAIL(cp) = erl_copy_term(TAIL(ep));
break;
case ERL_EMPTY_LIST:
break;
case ERL_TUPLE:
i = ERL_TUPLE_SIZE(cp) = ERL_TUPLE_SIZE(ep);
ERL_TUPLE_ELEMS(cp) = (ETERM**) erl_malloc(i * sizeof(ETERM*));
for(i=0; i < ERL_TUPLE_SIZE(ep); i++)
ERL_TUPLE_ELEMENT(cp,i) = erl_copy_term(ERL_TUPLE_ELEMENT(ep, i));
break;
case ERL_BINARY:
ERL_BIN_SIZE(cp) = ERL_BIN_SIZE(ep);
ERL_BIN_PTR(cp) = (unsigned char *) erl_malloc(ERL_BIN_SIZE(ep));
memcpy(ERL_BIN_PTR(cp), ERL_BIN_PTR(ep), ERL_BIN_SIZE(ep));
break;
case ERL_FUNCTION:
i = ERL_CLOSURE_SIZE(cp) = ERL_CLOSURE_SIZE(ep);
ERL_FUN_ARITY(cp) = ERL_FUN_ARITY(ep);
ERL_FUN_NEW_INDEX(cp) = ERL_FUN_NEW_INDEX(ep);
ERL_FUN_INDEX(cp) = erl_copy_term(ERL_FUN_INDEX(ep));
ERL_FUN_UNIQ(cp) = erl_copy_term(ERL_FUN_UNIQ(ep));
ERL_FUN_CREATOR(cp) = erl_copy_term(ERL_FUN_CREATOR(ep));
ERL_FUN_MODULE(cp) = erl_copy_term(ERL_FUN_MODULE(ep));
memcpy(ERL_FUN_MD5(cp), ERL_FUN_MD5(ep), sizeof(ERL_FUN_MD5(ep)));
ERL_CLOSURE(cp) = (ETERM**) erl_malloc(i * sizeof(ETERM*));
for(i=0; i < ERL_CLOSURE_SIZE(ep); i++)
ERL_CLOSURE_ELEMENT(cp,i) =
erl_copy_term(ERL_CLOSURE_ELEMENT(ep, i));
break;
default:
erl_err_msg("<ERROR> erl_copy_term: wrong type encountered !");
erl_free_term(cp);
return (ETERM *) NULL;
}
return cp;
}
int erl_print_term(FILE *fp, const ETERM *ep)
{
int j,i,doquote;
int ch_written = 0; /* counter of written chars */
if ((!fp) || (!ep)) return 0;
/* ASSERT(ep != NULL); */
j = i = doquote = 0;
switch(ERL_TYPE(ep))
{
case ERL_ATOM: {
char* adata = ERL_ATOM_PTR(ep);
/* FIXME: what if some weird locale is in use? */
if (!islower(adata[0]))
doquote = 1;
for (i = 0; !doquote && i < ERL_ATOM_SIZE(ep); i++)
{
doquote = !(isalnum(adata[i]) || (adata[i] == '_'));
}
if (doquote) {
putc('\'', fp);
ch_written++;
}
fputs(adata, fp);
ch_written += ERL_ATOM_SIZE(ep);
if (doquote) {
putc('\'', fp);
ch_written++;
}
break;
}
case ERL_VARIABLE:
if (!isupper((int)ERL_VAR_NAME(ep)[0])) {
doquote = 1;
putc('\'', fp);
ch_written++;
}
fputs(ERL_VAR_NAME(ep), fp);
ch_written += ERL_VAR_LEN(ep);
if (doquote) {
putc('\'', fp);
ch_written++;
}
break;
case ERL_PID:
ch_written += fprintf(fp, "<%s.%d.%d>",
ERL_PID_NODE(ep),
ERL_PID_NUMBER(ep), ERL_PID_SERIAL(ep));
break;
case ERL_PORT:
ch_written += fprintf(fp, "#Port");
break;
case ERL_REF:
ch_written += fprintf(fp, "#Ref");
break;
case ERL_EMPTY_LIST:
ch_written += fprintf(fp, "[]");
break;
case ERL_LIST:
if (is_printable_list(ep)) {
ch_written += print_string(fp, ep);
} else {
putc('[', fp);
ch_written++;
while (ERL_IS_CONS(ep)) {
ch_written += erl_print_term(fp, HEAD(ep));
ep = TAIL(ep);
if (ERL_IS_CONS(ep)) {
putc(',', fp);
ch_written++;
}
}
if (!ERL_IS_EMPTY_LIST(ep)) {
putc('|', fp);
ch_written++;
ch_written += erl_print_term(fp, ep);
}
putc(']', fp);
ch_written++;
}
break;
case ERL_TUPLE:
putc('{', fp);
ch_written++;
for (i=0; i < ERL_TUPLE_SIZE(ep); i++) {
ch_written += erl_print_term(fp, ERL_TUPLE_ELEMENT(ep, j++) );
if (i != ERL_TUPLE_SIZE(ep)-1) {
putc(',', fp);
ch_written++;
}
}
putc('}', fp);
ch_written++;
break;
case ERL_BINARY: {
int sz = (ERL_BIN_SIZE(ep) > 20) ? 20 : ERL_BIN_SIZE(ep);
unsigned char *ptr = ERL_BIN_PTR(ep);
ch_written += fprintf(fp, "#Bin<");
for (i = 0; i < sz; i++) {
putc(ptr[i], fp); ch_written++;
}
if (sz == 20) ch_written += fprintf(fp, "(%d)....>", ERL_BIN_SIZE(ep)-20);
else ch_written += fprintf(fp, ">");
break;
}
case ERL_INTEGER:
case ERL_SMALL_BIG:
ch_written += fprintf(fp, "%d", ERL_INT_VALUE(ep));
break;
case ERL_U_INTEGER:
case ERL_U_SMALL_BIG:
ch_written += fprintf(fp, "%d", ERL_INT_UVALUE(ep));
break;
case ERL_LONGLONG:
case ERL_U_LONGLONG:
ch_written += fprintf(fp, "%lld", ERL_LL_UVALUE(ep));
break;
case ERL_FLOAT:
ch_written += fprintf(fp, "%f", ERL_FLOAT_VALUE(ep));
break;
case ERL_FUNCTION:
ch_written += fprintf(fp, "#Fun<");
ch_written += erl_print_term(fp, ERL_FUN_MODULE(ep));
putc('.', fp);
ch_written++;
ch_written += erl_print_term(fp, ERL_FUN_INDEX(ep));
putc('.', fp);
ch_written++;
ch_written += erl_print_term(fp, ERL_FUN_UNIQ(ep));
putc('>', fp);
ch_written++;
break;
default:
ch_written = -10000;
erl_err_msg("<ERROR> erl_print_term: Bad type of term !");
}
return ch_written;
}
/*
Changescore for ESPs based on two-paths in undirected graphs i.e. configurations for edge i<->j such that i<->k<->j (where <-> here denotes an undirected edge).
UTP:
L2th - count t<->k<->h
L2tk - for each t<->k neq h: k<->h, count u such that k<->u<->h
L2hk - for each h<->k neq t: k<->t, count u such that k<->u<->t
This function will only work properly with undirected graphs, and should only be called in that case.
*/
void dspUTP_calc(Edge ntoggles, Vertex *tails, Vertex *heads, ModelTerm *mtp, Network *nwp, int nd, double *dvec, double *cs) {
Edge e, f;
int i, j, echange;
int L2th, L2tu, L2uh;
Vertex deg;
Vertex tail, head, u, v;
for(i=0;i<nd;i++) /*Initialize the changestat vector*/
cs[i]=0.0;
//Rprintf("dvec:\n");
//for(i=0;i<nd;i++)
// Rprintf("%d ",(int)dvec[i]);
//Rprintf("\n");
FOR_EACH_TOGGLE(i) {
L2th=0;
echange = (IS_OUTEDGE(tail=TAIL(i), head=HEAD(i)) == 0) ? 1 : -1;
/* step through outedges of head */
STEP_THROUGH_OUTEDGES(head,e,u){
if (IS_UNDIRECTED_EDGE(u,tail) != 0){
L2th++;
L2tu=0;
L2uh=0;
/* step through outedges of u */
STEP_THROUGH_OUTEDGES(u,f,v){
if(IS_UNDIRECTED_EDGE(v,head)!= 0) L2uh++;
if(IS_UNDIRECTED_EDGE(v,tail)!= 0) L2tu++;
}
/* step through inedges of u */
STEP_THROUGH_INEDGES(u,f,v){
if(IS_UNDIRECTED_EDGE(v,head)!= 0) L2uh++;
if(IS_UNDIRECTED_EDGE(v,tail)!= 0) L2tu++;
}
for(j = 0; j < nd; j++){
deg = (Vertex)dvec[j];
cs[j] += ((L2tu + echange == deg) - (L2tu == deg));
cs[j] += ((L2uh + echange == deg) - (L2uh == deg));
}
}
}
/* step through inedges of head */
STEP_THROUGH_INEDGES(head,e,u){
if (IS_UNDIRECTED_EDGE(u,tail) != 0){
L2th++;
L2tu=0;
L2uh=0;
/* step through outedges of u */
STEP_THROUGH_OUTEDGES(u,f,v){
if(IS_UNDIRECTED_EDGE(v,head)!= 0) L2uh++;
if(IS_UNDIRECTED_EDGE(v,tail)!= 0) L2tu++;
}
/* step through inedges of u */
STEP_THROUGH_INEDGES(u,f,v){
if(IS_UNDIRECTED_EDGE(v,head)!= 0) L2uh++;
if(IS_UNDIRECTED_EDGE(v,tail)!= 0) L2tu++;
}
for(j = 0; j < nd; j++){
deg = (Vertex)dvec[j];
cs[j] += ((L2tu + echange == deg) - (L2tu == deg));
cs[j] += ((L2uh + echange == deg) - (L2uh == deg));
}
}
}
/*
* format of file read by nsupdate is kept the same as the log
* file generated by updates, so that the log file can be fed
* to nsupdate to reconstruct lost updates.
*
* file is read on line at a time using fgets() rather than
* one word at a time using getword() so that it is easy to
* adapt nsupdate to read piped input from other scripts
*
* overloading of class/type has to be deferred to res_update()
* because class is needed by res_update() to determined the
* zone to which a resource record belongs
*/
int
main(int argc, char **argv) {
FILE *fp = NULL;
char buf[BUFSIZ], buf2[BUFSIZ];
char dnbuf[MAXDNAME], data[MAXDATA];
char *r_dname, *cp, *startp, *endp, *svstartp;
char section[15], opcode[10];
int i, c, n, n1, inside, lineno = 0, vc = 0,
debug = 0, r_size, r_section, r_opcode,
prompt = 0, ret = 0, stringtobin = 0;
int16_t r_class, r_type;
u_int32_t r_ttl;
struct map *mp;
ns_updrec *rrecp;
ns_updque listuprec;
extern int getopt();
extern char *optarg;
extern int optind, opterr, optopt;
ns_tsig_key key;
char *keyfile=NULL, *keyname=NULL;
progname = argv[0];
while ((c = getopt(argc, argv, "dsvk:n:")) != -1) {
switch (c) {
case 'v':
vc = 1;
break;
case 'd':
debug = 1;
break;
case 's':
stringtobin = 1;
break;
case 'k': {
/* -k keydir:keyname */
char *colon;
if ((colon=strchr(optarg, ':'))==NULL) {
fprintf(stderr, "key option argument should be keydir:keyname\n");
exit(1);
}
keyname=colon+1;
keyfile=optarg;
*colon='\0';
break;
}
case 'n':
keyname=optarg;
break;
default:
usage();
}
}
INIT_LIST(listuprec);
if (keyfile) {
#ifdef PARSE_KEYFILE
if ((fp=fopen(keyfile, "r"))==NULL) {
perror("open keyfile");
exit(1);
}
/* now read the header info from the file */
if ((i=fread(buf, 1, BUFSIZ, fp)) < 5) {
fclose(fp);
exit(1);
}
fclose(fp);
fp=NULL;
p=buf;
n=strlen(p); /* get length of strings */
n1=strlen("Private-key-format: v");
if (n1 > n || strncmp(buf, "Private-key-format: v", n1)) {
fprintf(stderr, "Invalid key file format\n");
exit(1); /* not a match */
}
p+=n1; /* advance pointer */
sscanf((char *)p, "%d.%d", &file_major, &file_minor);
/* should do some error checking with these someday */
while (*p++!='\n'); /* skip to end of line */
n=strlen(p); /* get length of strings */
n1=strlen("Algorithm: ");
if (n1 > n || strncmp(p, "Algorithm: ", n1)) {
fprintf(stderr, "Invalid key file format\n");
exit(1); /* not a match */
}
p+=n1; /* advance pointer */
if (sscanf((char *)p, "%d", &alg)!=1) {
fprintf(stderr, "Invalid key file format\n");
exit(1);
}
while (*p++!='\n'); /* skip to end of line */
n=strlen(p); /* get length of strings */
n1=strlen("Key: ");
if (n1 > n || strncmp(p, "Key: ", n1)) {
fprintf(stderr, "Invalid key file format\n");
exit(1); /* not a match */
}
p+=n1; /* advance pointer */
pp=p;
while (*pp++!='\n'); /* skip to end of line, terminate it */
*--pp='\0';
key.data=malloc(1024*sizeof(char));
key.len=b64_pton(p, key.data, 1024);
strcpy(key.name, keyname);
strcpy(key.alg, "HMAC-MD5.SIG-ALG.REG.INT");
#else
/* use the dst* routines to parse the key files
*
* This requires that both the .key and the .private files
* exist in your cwd, so the keyfile parmeter here is
* assumed to be a path in which the K*.{key,private} files
* exist.
*/
DST_KEY *dst_key;
char cwd[PATH_MAX+1];
if (getcwd(cwd, PATH_MAX)==NULL) {
perror("unable to get current directory");
exit(1);
}
if (chdir(keyfile)<0) {
fprintf(stderr, "unable to chdir to %s: %s\n", keyfile,
strerror(errno));
exit(1);
}
dst_init();
dst_key = dst_read_key(keyname,
0 /* not used for private keys */,
KEY_HMAC_MD5, DST_PRIVATE);
if (!dst_key) {
fprintf(stderr, "dst_read_key: error reading key\n");
exit(1);
}
key.data=malloc(1024*sizeof(char));
dst_key_to_buffer(dst_key, key.data, 1024);
key.len=dst_key->dk_key_size;
strcpy(key.name, keyname);
strcpy(key.alg, "HMAC-MD5.SIG-ALG.REG.INT");
if (chdir(cwd)<0) {
fprintf(stderr, "unable to chdir to %s: %s\n", cwd,
strerror(errno));
exit(1);
}
#endif
}
if ((argc - optind) == 0) {
/* no file specified, read from stdin */
ret = system("tty -s");
if (ret == 0) /* terminal */
prompt = 1;
else /* stdin redirect from a file or a pipe */
prompt = 0;
} else {
/* file specified, open it */
/* XXX - currently accepts only one filename */
if ((fp = fopen(argv[optind], "r")) == NULL) {
fprintf(stderr, "error opening file: %s\n", argv[optind]);
exit (1);
}
}
for (;;) {
inside = 1;
if (prompt)
fprintf(stdout, "> ");
if (!fp)
cp = fgets(buf, sizeof buf, stdin);
else
cp = fgets(buf, sizeof buf, fp);
if (cp == NULL) /* EOF */
break;
lineno++;
/* get rid of the trailing newline */
n = strlen(buf);
buf[--n] = '\0';
startp = cp;
endp = strchr(cp, ';');
if (endp != NULL)
endp--;
else
endp = cp + n - 1;
/* verify section name */
if (!getword_str(section, sizeof section, &startp, endp)) {
/* empty line */
inside = 0;
}
if (inside) {
/* inside the same update packet,
* continue accumulating records */
r_section = -1;
n1 = strlen(section);
if (section[n1-1] == ':')
section[--n1] = '\0';
for (mp = section_strs; mp < section_strs+M_SECTION_CNT; mp++)
if (!strcasecmp(section, mp->token)) {
r_section = mp->val;
break;
}
if (r_section == -1) {
fprintf(stderr, "incorrect section name: %s\n", section);
exit (1);
}
if (r_section == S_ZONE) {
fprintf(stderr, "section ZONE not permitted\n");
exit (1);
}
/* read operation code */
if (!getword_str(opcode, sizeof opcode, &startp, endp)) {
fprintf(stderr, "failed to read operation code\n");
exit (1);
}
r_opcode = -1;
if (opcode[0] == '{') {
n1 = strlen(opcode);
for (i = 0; i < n1; i++)
opcode[i] = opcode[i+1];
if (opcode[n1-2] == '}')
opcode[n1-2] = '\0';
}
for (mp = opcode_strs; mp < opcode_strs+M_OPCODE_CNT; mp++) {
if (!strcasecmp(opcode, mp->token)) {
r_opcode = mp->val;
break;
}
}
if (r_opcode == -1) {
fprintf(stderr, "incorrect operation code: %s\n", opcode);
exit (1);
}
/* read owner's domain name */
if (!getword_str(dnbuf, sizeof dnbuf, &startp, endp)) {
fprintf(stderr, "failed to read owner name\n");
exit (1);
}
r_dname = dnbuf;
r_ttl = (r_opcode == ADD) ? (~0U) : 0;
r_type = -1;
r_class = C_IN; /* default to IN */
r_size = 0;
(void) getword_str(buf2, sizeof buf2, &startp, endp);
if (isdigit(buf2[0])) { /* ttl */
r_ttl = strtoul(buf2, 0, 10);
if (errno == ERANGE && r_ttl == ULONG_MAX) {
fprintf(stderr, "oversized ttl: %s\n", buf2);
exit (1);
}
(void) getword_str(buf2, sizeof buf2, &startp, endp);
}
if (buf2[0]) { /* possibly class */
for (mp = class_strs; mp < class_strs+M_CLASS_CNT; mp++) {
if (!strcasecmp(buf2, mp->token)) {
r_class = mp->val;
(void) getword_str(buf2, sizeof buf2, &startp, endp);
break;
}
}
}
/*
* type and rdata field may or may not be required depending
* on the section and operation
*/
switch (r_section) {
case S_PREREQ:
if (r_ttl) {
fprintf(stderr, "nonzero ttl in prereq section: %lu\n",
(u_long)r_ttl);
r_ttl = 0;
}
switch (r_opcode) {
case NXDOMAIN:
case YXDOMAIN:
if (buf2[0]) {
fprintf (stderr, "invalid field: %s, ignored\n",
buf2);
exit (1);
}
break;
case NXRRSET:
case YXRRSET:
if (buf2[0])
for (mp = type_strs; mp < type_strs+M_TYPE_CNT; mp++)
if (!strcasecmp(buf2, mp->token)) {
r_type = mp->val;
break;
}
if (r_type == -1) {
fprintf (stderr, "invalid type for RRset: %s\n",
buf2);
exit (1);
}
if (r_opcode == NXRRSET)
break;
/*
* for RRset exists (value dependent) case,
* nonempty rdata field will be present.
* simply copy the whole string now and let
* res_update() interpret the various fields
* depending on type
*/
cp = startp;
while (cp <= endp && isspace(*cp))
cp++;
r_size = endp - cp + 1;
break;
default:
fprintf (stderr,
"unknown operation in prereq section\"%s\"\n",
opcode);
exit (1);
}
break;
case S_UPDATE:
switch (r_opcode) {
case DELETE:
r_ttl = 0;
r_type = T_ANY;
/* read type, if specified */
if (buf2[0])
for (mp = type_strs; mp < type_strs+M_TYPE_CNT; mp++)
if (!strcasecmp(buf2, mp->token)) {
r_type = mp->val;
svstartp = startp;
(void) getword_str(buf2, sizeof buf2,
&startp, endp);
if (buf2[0]) /* unget preference */
startp = svstartp;
break;
}
/* read rdata portion, if specified */
cp = startp;
while (cp <= endp && isspace(*cp))
cp++;
r_size = endp - cp + 1;
break;
case ADD:
if (r_ttl == ~0U) {
fprintf (stderr,
"ttl must be specified for record to be added: %s\n", buf);
exit (1);
}
/* read type */
if (buf2[0])
for (mp = type_strs; mp < type_strs+M_TYPE_CNT; mp++)
if (!strcasecmp(buf2, mp->token)) {
r_type = mp->val;
break;
}
if (r_type == -1) {
fprintf(stderr,
"invalid type for record to be added: %s\n", buf2);
exit (1);
}
/* read rdata portion */
cp = startp;
while (cp < endp && isspace(*cp))
cp++;
r_size = endp - cp + 1;
if (r_size <= 0) {
fprintf(stderr,
"nonempty rdata field needed to add the record at line %d\n",
lineno);
exit (1);
}
break;
default:
fprintf(stderr,
"unknown operation in update section \"%s\"\n", opcode);
exit (1);
}
break;
default:
fprintf(stderr,
"unknown section identifier \"%s\"\n", section);
exit (1);
}
if ( !(rrecp = res_mkupdrec(r_section, r_dname, r_class,
r_type, r_ttl)) ||
(r_size > 0 && !(rrecp->r_data = (u_char *)malloc(r_size))) ) {
if (rrecp)
res_freeupdrec(rrecp);
fprintf(stderr, "saverrec error\n");
exit (1);
}
if (stringtobin) {
switch(r_opcode) {
case T_HINFO:
if (!getcharstring(buf,(char *)data,2,2,lineno))
exit(1);
cp = data;
break;
case T_ISDN:
if (!getcharstring(buf,(char *)data,1,2,lineno))
exit(1);
cp = data;
break;
case T_TXT:
if (!getcharstring(buf,(char *)data,1,0,lineno))
exit(1);
cp = data;
break;
case T_X25:
if (!getcharstring(buf,(char *)data,1,1,lineno))
exit(1);
cp = data;
break;
default:
break;
}
}
rrecp->r_opcode = r_opcode;
rrecp->r_size = r_size;
(void) strncpy((char *)rrecp->r_data, cp, r_size);
APPEND(listuprec, rrecp, r_link);
} else { /* end of an update packet */
(void) res_ninit(&res);
if (vc)
res.options |= RES_USEVC | RES_STAYOPEN;
if (debug)
res.options |= RES_DEBUG;
if (!EMPTY(listuprec)) {
n = res_nupdate(&res, HEAD(listuprec),
keyfile != NULL ? &key : NULL);
if (n < 0)
fprintf(stderr, "failed update packet\n");
while (!EMPTY(listuprec)) {
ns_updrec *tmprrecp = HEAD(listuprec);
UNLINK(listuprec, tmprrecp, r_link);
if (tmprrecp->r_size != 0)
free((char *)tmprrecp->r_data);
res_freeupdrec(tmprrecp);
}
}
}
} /* for */
return (0);
}
ISC_TASKFUNC_SCOPE void
isc__taskmgr_destroy(isc_taskmgr_t **managerp) {
isc__taskmgr_t *manager;
isc__task_t *task;
unsigned int i;
/*
* Destroy '*managerp'.
*/
REQUIRE(managerp != NULL);
manager = (isc__taskmgr_t *)*managerp;
REQUIRE(VALID_MANAGER(manager));
#ifndef USE_WORKER_THREADS
UNUSED(i);
#endif /* USE_WORKER_THREADS */
#ifdef USE_SHARED_MANAGER
manager->refs--;
if (manager->refs > 0) {
*managerp = NULL;
return;
}
#endif
XTHREADTRACE("isc_taskmgr_destroy");
/*
* Only one non-worker thread may ever call this routine.
* If a worker thread wants to initiate shutdown of the
* task manager, it should ask some non-worker thread to call
* isc_taskmgr_destroy(), e.g. by signalling a condition variable
* that the startup thread is sleeping on.
*/
/*
* Detach the exclusive task before acquiring the manager lock
*/
if (manager->excl != NULL)
isc__task_detach((isc_task_t **) &manager->excl);
/*
* Unlike elsewhere, we're going to hold this lock a long time.
* We need to do so, because otherwise the list of tasks could
* change while we were traversing it.
*
* This is also the only function where we will hold both the
* task manager lock and a task lock at the same time.
*/
LOCK(&manager->lock);
/*
* Make sure we only get called once.
*/
INSIST(!manager->exiting);
manager->exiting = ISC_TRUE;
/*
* If privileged mode was on, turn it off.
*/
manager->mode = isc_taskmgrmode_normal;
/*
* Post shutdown event(s) to every task (if they haven't already been
* posted).
*/
for (task = HEAD(manager->tasks);
task != NULL;
task = NEXT(task, link)) {
LOCK(&task->lock);
if (task_shutdown(task))
push_readyq(manager, task);
UNLOCK(&task->lock);
}
#ifdef USE_WORKER_THREADS
/*
* Wake up any sleeping workers. This ensures we get work done if
* there's work left to do, and if there are already no tasks left
* it will cause the workers to see manager->exiting.
*/
BROADCAST(&manager->work_available);
UNLOCK(&manager->lock);
/*
* Wait for all the worker threads to exit.
*/
for (i = 0; i < manager->workers; i++)
(void)isc_thread_join(manager->threads[i], NULL);
#else /* USE_WORKER_THREADS */
/*
* Dispatch the shutdown events.
*/
UNLOCK(&manager->lock);
while (isc__taskmgr_ready((isc_taskmgr_t *)manager))
(void)isc__taskmgr_dispatch((isc_taskmgr_t *)manager);
if (!ISC_LIST_EMPTY(manager->tasks))
isc_mem_printallactive(stderr);
INSIST(ISC_LIST_EMPTY(manager->tasks));
#ifdef USE_SHARED_MANAGER
taskmgr = NULL;
#endif
#endif /* USE_WORKER_THREADS */
manager_free(manager);
*managerp = NULL;
}
static void
dispatch(isc__taskmgr_t *manager) {
isc__task_t *task;
#ifndef USE_WORKER_THREADS
unsigned int total_dispatch_count = 0;
isc__tasklist_t new_ready_tasks;
isc__tasklist_t new_priority_tasks;
#endif /* USE_WORKER_THREADS */
REQUIRE(VALID_MANAGER(manager));
/*
* Again we're trying to hold the lock for as short a time as possible
* and to do as little locking and unlocking as possible.
*
* In both while loops, the appropriate lock must be held before the
* while body starts. Code which acquired the lock at the top of
* the loop would be more readable, but would result in a lot of
* extra locking. Compare:
*
* Straightforward:
*
* LOCK();
* ...
* UNLOCK();
* while (expression) {
* LOCK();
* ...
* UNLOCK();
*
* Unlocked part here...
*
* LOCK();
* ...
* UNLOCK();
* }
*
* Note how if the loop continues we unlock and then immediately lock.
* For N iterations of the loop, this code does 2N+1 locks and 2N+1
* unlocks. Also note that the lock is not held when the while
* condition is tested, which may or may not be important, depending
* on the expression.
*
* As written:
*
* LOCK();
* while (expression) {
* ...
* UNLOCK();
*
* Unlocked part here...
*
* LOCK();
* ...
* }
* UNLOCK();
*
* For N iterations of the loop, this code does N+1 locks and N+1
* unlocks. The while expression is always protected by the lock.
*/
#ifndef USE_WORKER_THREADS
ISC_LIST_INIT(new_ready_tasks);
ISC_LIST_INIT(new_priority_tasks);
#endif
LOCK(&manager->lock);
while (!FINISHED(manager)) {
#ifdef USE_WORKER_THREADS
/*
* For reasons similar to those given in the comment in
* isc_task_send() above, it is safe for us to dequeue
* the task while only holding the manager lock, and then
* change the task to running state while only holding the
* task lock.
*
* If a pause has been requested, don't do any work
* until it's been released.
*/
while ((empty_readyq(manager) || manager->pause_requested ||
manager->exclusive_requested) && !FINISHED(manager))
{
XTHREADTRACE(isc_msgcat_get(isc_msgcat,
ISC_MSGSET_GENERAL,
ISC_MSG_WAIT, "wait"));
WAIT(&manager->work_available, &manager->lock);
XTHREADTRACE(isc_msgcat_get(isc_msgcat,
ISC_MSGSET_TASK,
ISC_MSG_AWAKE, "awake"));
}
#else /* USE_WORKER_THREADS */
if (total_dispatch_count >= DEFAULT_TASKMGR_QUANTUM ||
empty_readyq(manager))
break;
#endif /* USE_WORKER_THREADS */
XTHREADTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TASK,
ISC_MSG_WORKING, "working"));
task = pop_readyq(manager);
if (task != NULL) {
unsigned int dispatch_count = 0;
isc_boolean_t done = ISC_FALSE;
isc_boolean_t requeue = ISC_FALSE;
isc_boolean_t finished = ISC_FALSE;
isc_event_t *event;
INSIST(VALID_TASK(task));
/*
* Note we only unlock the manager lock if we actually
* have a task to do. We must reacquire the manager
* lock before exiting the 'if (task != NULL)' block.
*/
manager->tasks_running++;
UNLOCK(&manager->lock);
LOCK(&task->lock);
INSIST(task->state == task_state_ready);
task->state = task_state_running;
XTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
ISC_MSG_RUNNING, "running"));
isc_stdtime_get(&task->now);
do {
if (!EMPTY(task->events)) {
event = HEAD(task->events);
DEQUEUE(task->events, event, ev_link);
/*
* Execute the event action.
*/
XTRACE(isc_msgcat_get(isc_msgcat,
ISC_MSGSET_TASK,
ISC_MSG_EXECUTE,
"execute action"));
if (event->ev_action != NULL) {
UNLOCK(&task->lock);
(event->ev_action)(
(isc_task_t *)task,
event);
LOCK(&task->lock);
}
dispatch_count++;
#ifndef USE_WORKER_THREADS
total_dispatch_count++;
#endif /* USE_WORKER_THREADS */
}
if (task->references == 0 &&
EMPTY(task->events) &&
!TASK_SHUTTINGDOWN(task)) {
isc_boolean_t was_idle;
/*
* There are no references and no
* pending events for this task,
* which means it will not become
* runnable again via an external
* action (such as sending an event
* or detaching).
*
* We initiate shutdown to prevent
* it from becoming a zombie.
*
* We do this here instead of in
* the "if EMPTY(task->events)" block
* below because:
*
* If we post no shutdown events,
* we want the task to finish.
*
* If we did post shutdown events,
* will still want the task's
* quantum to be applied.
*/
was_idle = task_shutdown(task);
INSIST(!was_idle);
}
if (EMPTY(task->events)) {
/*
* Nothing else to do for this task
* right now.
*/
XTRACE(isc_msgcat_get(isc_msgcat,
ISC_MSGSET_TASK,
ISC_MSG_EMPTY,
"empty"));
if (task->references == 0 &&
TASK_SHUTTINGDOWN(task)) {
/*
* The task is done.
*/
XTRACE(isc_msgcat_get(
isc_msgcat,
ISC_MSGSET_TASK,
ISC_MSG_DONE,
"done"));
finished = ISC_TRUE;
task->state = task_state_done;
} else
task->state = task_state_idle;
done = ISC_TRUE;
} else if (dispatch_count >= task->quantum) {
/*
* Our quantum has expired, but
* there is more work to be done.
* We'll requeue it to the ready
* queue later.
*
* We don't check quantum until
* dispatching at least one event,
* so the minimum quantum is one.
*/
XTRACE(isc_msgcat_get(isc_msgcat,
ISC_MSGSET_TASK,
ISC_MSG_QUANTUM,
"quantum"));
task->state = task_state_ready;
requeue = ISC_TRUE;
done = ISC_TRUE;
}
} while (!done);
UNLOCK(&task->lock);
if (finished)
task_finished(task);
LOCK(&manager->lock);
manager->tasks_running--;
#ifdef USE_WORKER_THREADS
if (manager->exclusive_requested &&
manager->tasks_running == 1) {
SIGNAL(&manager->exclusive_granted);
} else if (manager->pause_requested &&
manager->tasks_running == 0) {
SIGNAL(&manager->paused);
}
#endif /* USE_WORKER_THREADS */
if (requeue) {
/*
* We know we're awake, so we don't have
* to wakeup any sleeping threads if the
* ready queue is empty before we requeue.
*
* A possible optimization if the queue is
* empty is to 'goto' the 'if (task != NULL)'
* block, avoiding the ENQUEUE of the task
* and the subsequent immediate DEQUEUE
* (since it is the only executable task).
* We don't do this because then we'd be
* skipping the exit_requested check. The
* cost of ENQUEUE is low anyway, especially
* when you consider that we'd have to do
* an extra EMPTY check to see if we could
* do the optimization. If the ready queue
* were usually nonempty, the 'optimization'
* might even hurt rather than help.
*/
#ifdef USE_WORKER_THREADS
push_readyq(manager, task);
#else
ENQUEUE(new_ready_tasks, task, ready_link);
if ((task->flags & TASK_F_PRIVILEGED) != 0)
ENQUEUE(new_priority_tasks, task,
ready_priority_link);
#endif
}
}
#ifdef USE_WORKER_THREADS
/*
* If we are in privileged execution mode and there are no
* tasks remaining on the current ready queue, then
* we're stuck. Automatically drop privileges at that
* point and continue with the regular ready queue.
*/
if (manager->tasks_running == 0 && empty_readyq(manager)) {
manager->mode = isc_taskmgrmode_normal;
if (!empty_readyq(manager))
BROADCAST(&manager->work_available);
}
#endif
}
#ifndef USE_WORKER_THREADS
ISC_LIST_APPENDLIST(manager->ready_tasks, new_ready_tasks, ready_link);
ISC_LIST_APPENDLIST(manager->ready_priority_tasks, new_priority_tasks,
ready_priority_link);
if (empty_readyq(manager))
manager->mode = isc_taskmgrmode_normal;
#endif
UNLOCK(&manager->lock);
}
static void
write_externs(void)
{
entity *list = NULL;
tree *current = NULL;
char *name;
tree *args = NULL;
tree *symbol = NULL;
gp_boolean first_time = true;
int storage;
list = state.list;
while (list != NULL) {
current = list->node;
/* CLEAN THIS UP !! */
switch(current->tag) {
case node_decl:
storage = current->value.decl.storage;
break;
case node_func:
storage = current->value.func.storage;
break;
case node_proc:
storage = current->value.proc.storage;
break;
default:
assert(0);
}
if (storage == EXTERN_STORAGE) {
if (first_time == true) {
fprintf(state.output.f, "; external symbols\n");
first_time = false;
}
switch(current->tag) {
case node_decl:
symbol = HEAD(current->value.decl.expr);
extern_name(symbol->value.symbol, NULL, symbol);
break;
case node_func:
name = current->value.func.head->value.head.name;
args = current->value.func.head->value.head.args;
extern_name(name, NULL, current);
extern_args(name, args);
break;
case node_proc:
name = current->value.proc.head->value.head.name;
args = current->value.proc.head->value.head.args;
extern_name(name, NULL, current);
extern_args(name, args);
break;
default:
assert(0);
}
}
list = list->next;
}
if (first_time == false)
fprintf(state.output.f, "\n");
return;
}
static void
write_procedure(tree *procedure, int is_func)
{
tree *head;
tree *body;
char *name;
tree *args;
tree *decl;
tree *statements;
tree *argument;
int i;
int storage;
if (is_func) {
head = procedure->value.func.head;
storage = procedure->value.func.storage;
body = procedure->value.func.body;
} else {
head = procedure->value.proc.head;
storage = procedure->value.proc.storage;
body = procedure->value.proc.body;
}
if (storage == EXTERN_STORAGE)
return;
assert(head->tag == node_head);
assert(body->tag == node_body);
name = head->value.head.name;
args = head->value.head.args;
decl = body->value.body.decl;
statements = body->value.body.statements;
if (is_func) {
fprintf(state.output.f, "; function %s\n", name);
} else {
fprintf(state.output.f, "; procedure %s\n", name);
}
/* data memory section */
if ((args != NULL) || (decl != NULL)) {
fprintf(state.output.f, ".udata_%s udata\n", name);
/* the procedure or function has arguments */
if (args != NULL) {
assert(args->tag == node_list);
for (; args; args = TAIL(args)) {
argument = HEAD(args);
assert(argument->tag == node_decl);
assert(argument->value.decl.type == 0);
assert(argument->value.decl.storage == 0);
/* FIXME: only bytes are supported so far */
assert(argument->value.decl.size == BYTE_SIZE);
write_decl(argument, name);
}
}
/* the procedure or function has local variables */
if (decl != NULL) {
assert(decl->tag == node_list);
for (; decl; decl = TAIL(decl)) {
argument = HEAD(decl);
assert(argument->tag == node_decl);
assert(argument->value.decl.storage == 0);
/* FIXME: only bytes are supported so far */
assert(argument->value.decl.size == BYTE_SIZE);
if (argument->value.decl.type == VAR_TYPE)
write_decl(argument, name);
}
}
fprintf(state.output.f, "\n");
}
/* program memory section */
fprintf(state.output.f, ".code_%s code\n", name);
add_global(name, name, procedure);
write_label(name);
if (storage == PUBLIC_STORAGE)
fprintf(state.output.f, " global %s\n", name);
max_temp_number = 0;
write_statements(statements);
fprintf(state.output.f, " return\n");
fprintf(state.output.f, "\n");
/* temp data section */
if (max_temp_number) {
/* FIXME: overlay this if possible */
fprintf(state.output.f, ".udata_%s_temp udata\n", name);
for(i = 0; i < max_temp_number; i++)
fprintf(state.output.f, "_temp_%d res 1\n", i);
fprintf(state.output.f, "\n");
}
}
int fswc_grab(fswebcam_config_t *config)
{
uint32_t frame;
uint32_t x, y;
avgbmp_t *abitmap, *pbitmap;
gdImage *image, *original;
uint8_t modified;
src_t src;
/* Record the start time. */
config->start = time(NULL);
/* Set source options... */
memset(&src, 0, sizeof(src));
src.input = config->input;
src.tuner = config->tuner;
src.frequency = config->frequency;
src.delay = config->delay;
src.timeout = 10; /* seconds */
src.use_read = config->use_read;
src.list = config->list;
src.palette = config->palette;
src.width = config->width;
src.height = config->height;
src.fps = config->fps;
src.option = config->option;
HEAD("--- Opening %s...", config->device);
if(src_open(&src, config->device) == -1) return(-1);
/* The source may have adjusted the width and height we passed
* to it. Update the main config to match. */
config->width = src.width;
config->height = src.height;
/* Allocate memory for the average bitmap buffer. */
abitmap = calloc(config->width * config->height * 3, sizeof(avgbmp_t));
if(!abitmap)
{
ERROR("Out of memory.");
return(-1);
}
if(config->frames == 1) HEAD("--- Capturing frame...");
else HEAD("--- Capturing %i frames...", config->frames);
if(config->skipframes == 1) MSG("Skipping frame...");
else if(config->skipframes > 1) MSG("Skipping %i frames...", config->skipframes);
/* Grab (and do nothing with) the skipped frames. */
for(frame = 0; frame < config->skipframes; frame++)
if(src_grab(&src) == -1) break;
/* If frames where skipped, inform when normal capture begins. */
if(config->skipframes) MSG("Capturing %i frames...", config->frames);
/* Grab the requested number of frames. */
for(frame = 0; frame < config->frames; frame++)
{
if(src_grab(&src) == -1) break;
if(!frame && config->dumpframe)
{
/* Dump the raw data from the first frame to file. */
FILE *f;
MSG("Dumping raw frame to '%s'...", config->dumpframe);
f = fopen(config->dumpframe, "wb");
if(!f) ERROR("fopen: %s", strerror(errno));
else
{
fwrite(src.img, 1, src.length, f);
fclose(f);
}
}
/* Add frame to the average bitmap. */
switch(src.palette)
{
case SRC_PAL_PNG:
fswc_add_image_png(&src, abitmap);
break;
case SRC_PAL_JPEG:
case SRC_PAL_MJPEG:
fswc_add_image_jpeg(&src, abitmap);
break;
case SRC_PAL_S561:
fswc_add_image_s561(abitmap, src.img, src.length, src.width, src.height, src.palette);
break;
case SRC_PAL_RGB32:
fswc_add_image_rgb32(&src, abitmap);
break;
case SRC_PAL_BGR32:
fswc_add_image_bgr32(&src, abitmap);
break;
case SRC_PAL_RGB24:
fswc_add_image_rgb24(&src, abitmap);
break;
case SRC_PAL_BGR24:
fswc_add_image_bgr24(&src, abitmap);
break;
case SRC_PAL_BAYER:
case SRC_PAL_SGBRG8:
case SRC_PAL_SGRBG8:
fswc_add_image_bayer(abitmap, src.img, src.length, src.width, src.height, src.palette);
break;
case SRC_PAL_YUYV:
case SRC_PAL_UYVY:
fswc_add_image_yuyv(&src, abitmap);
break;
case SRC_PAL_YUV420P:
fswc_add_image_yuv420p(&src, abitmap);
break;
case SRC_PAL_NV12MB:
fswc_add_image_nv12mb(&src, abitmap);
break;
case SRC_PAL_RGB565:
fswc_add_image_rgb565(&src, abitmap);
break;
case SRC_PAL_RGB555:
fswc_add_image_rgb555(&src, abitmap);
break;
case SRC_PAL_Y16:
fswc_add_image_y16(&src, abitmap);
break;
case SRC_PAL_GREY:
fswc_add_image_grey(&src, abitmap);
break;
}
}
/* We are now finished with the capture card. */
src_close(&src);
/* Fail if no frames where captured. */
if(!frame)
{
ERROR("No frames captured.");
free(abitmap);
return(-1);
}
HEAD("--- Processing captured image...");
/* Copy the average bitmap image to a gdImage. */
original = gdImageCreateTrueColor(config->width, config->height);
if(!original)
{
ERROR("Out of memory.");
free(abitmap);
return(-1);
}
pbitmap = abitmap;
for(y = 0; y < config->height; y++)
for(x = 0; x < config->width; x++)
{
int px = x;
int py = y;
int colour;
colour = (*(pbitmap++) / config->frames) << 16;
colour += (*(pbitmap++) / config->frames) << 8;
colour += (*(pbitmap++) / config->frames);
gdImageSetPixel(original, px, py, colour);
}
free(abitmap);
/* Make a copy of the original image. */
image = fswc_gdImageDuplicate(original);
if(!image)
{
ERROR("Out of memory.");
gdImageDestroy(image);
return(-1);
}
/* Set the default values for this run. */
if(config->font) free(config->font);
if(config->title) free(config->title);
if(config->subtitle) free(config->subtitle);
if(config->timestamp) free(config->timestamp);
if(config->info) free(config->info);
if(config->underlay) free(config->underlay);
if(config->overlay) free(config->overlay);
if(config->filename) free(config->filename);
config->banner = BOTTOM_BANNER;
config->bg_colour = 0x40263A93;
config->bl_colour = 0x00FF0000;
config->fg_colour = 0x00FFFFFF;
config->font = strdup("sans");
config->fontsize = 10;
config->shadow = 1;
config->title = NULL;
config->subtitle = NULL;
config->timestamp = strdup("%Y-%m-%d %H:%M (%Z)");
config->info = NULL;
config->underlay = NULL;
config->overlay = NULL;
config->filename = NULL;
config->format = FORMAT_JPEG;
config->compression = -1;
modified = 1;
/* Run through the jobs list. */
for(x = 0; x < config->jobs; x++)
{
uint16_t id = config->job[x]->id;
char *options = config->job[x]->options;
switch(id)
{
case 1: /* A non-option argument: a filename. */
case OPT_SAVE:
fswc_output(config, options, image);
modified = 0;
break;
case OPT_EXEC:
fswc_exec(config, options);
break;
case OPT_REVERT:
modified = 1;
gdImageDestroy(image);
image = fswc_gdImageDuplicate(original);
break;
case OPT_FLIP:
modified = 1;
image = fx_flip(image, options);
break;
case OPT_CROP:
modified = 1;
image = fx_crop(image, options);
break;
case OPT_SCALE:
modified = 1;
image = fx_scale(image, options);
break;
case OPT_ROTATE:
modified = 1;
image = fx_rotate(image, options);
break;
case OPT_DEINTERLACE:
modified = 1;
image = fx_deinterlace(image, options);
break;
case OPT_INVERT:
modified = 1;
image = fx_invert(image, options);
break;
case OPT_GREYSCALE:
modified = 1;
image = fx_greyscale(image, options);
break;
case OPT_SWAPCHANNELS:
modified = 1;
image = fx_swapchannels(image, options);
break;
case OPT_NO_BANNER:
modified = 1;
MSG("Disabling banner.");
config->banner = NO_BANNER;
break;
case OPT_TOP_BANNER:
modified = 1;
MSG("Putting banner at the top.");
config->banner = TOP_BANNER;
break;
case OPT_BOTTOM_BANNER:
modified = 1;
MSG("Putting banner at the bottom.");
config->banner = BOTTOM_BANNER;
break;
case OPT_BG_COLOUR:
modified = 1;
MSG("Setting banner background colour to %s.", options);
if(sscanf(options, "#%X", &config->bg_colour) != 1)
WARN("Bad background colour: %s", options);
break;
case OPT_BL_COLOUR:
modified = 1;
MSG("Setting banner line colour to %s.", options);
if(sscanf(options, "#%X", &config->bl_colour) != 1)
WARN("Bad line colour: %s", options);
break;
case OPT_FG_COLOUR:
modified = 1;
MSG("Setting banner text colour to %s.", options);
if(sscanf(options, "#%X", &config->fg_colour) != 1)
WARN("Bad text colour: %s", options);
break;
case OPT_FONT:
modified = 1;
MSG("Setting font to %s.", options);
if(parse_font(options, &config->font, &config->fontsize))
WARN("Bad font: %s", options);
break;
case OPT_NO_SHADOW:
modified = 1;
MSG("Disabling text shadow.");
config->shadow = 0;
break;
case OPT_SHADOW:
modified = 1;
MSG("Enabling text shadow.");
config->shadow = 1;
break;
case OPT_TITLE:
modified = 1;
MSG("Setting title \"%s\".", options);
if(config->title) free(config->title);
config->title = strdup(options);
break;
case OPT_NO_TITLE:
modified = 1;
MSG("Clearing title.");
if(config->title) free(config->title);
config->title = NULL;
break;
case OPT_SUBTITLE:
modified = 1;
MSG("Setting subtitle \"%s\".", options);
if(config->subtitle) free(config->subtitle);
config->subtitle = strdup(options);
break;
case OPT_NO_SUBTITLE:
modified = 1;
MSG("Clearing subtitle.");
if(config->subtitle) free(config->subtitle);
config->subtitle = NULL;
break;
case OPT_TIMESTAMP:
modified = 1;
MSG("Setting timestamp \"%s\".", options);
if(config->timestamp) free(config->timestamp);
config->timestamp = strdup(options);
break;
case OPT_NO_TIMESTAMP:
modified = 1;
MSG("Clearing timestamp.");
if(config->timestamp) free(config->timestamp);
config->timestamp = NULL;
break;
case OPT_INFO:
modified = 1;
MSG("Setting info text \"%s\".", options);
if(config->info) free(config->info);
config->info = strdup(options);
break;
case OPT_NO_INFO:
modified = 1;
MSG("Clearing info text.");
if(config->info) free(config->info);
config->info = NULL;
break;
case OPT_UNDERLAY:
modified = 1;
MSG("Setting underlay image: %s", options);
if(config->underlay) free(config->underlay);
config->underlay = strdup(options);
break;
case OPT_NO_UNDERLAY:
modified = 1;
MSG("Clearing underlay.");
if(config->underlay) free(config->underlay);
config->underlay = NULL;
break;
case OPT_OVERLAY:
modified = 1;
MSG("Setting overlay image: %s", options);
if(config->overlay) free(config->overlay);
config->overlay = strdup(options);
break;
case OPT_NO_OVERLAY:
modified = 1;
MSG("Clearing overlay image.");
if(config->overlay) free(config->overlay);
config->overlay = NULL;
break;
case OPT_JPEG:
modified = 1;
MSG("Setting output format to JPEG, quality %i", atoi(options));
config->format = FORMAT_JPEG;
config->compression = atoi(options);
break;
case OPT_PNG:
modified = 1;
MSG("Setting output format to PNG, quality %i", atoi(options));
config->format = FORMAT_PNG;
config->compression = atoi(options);
break;
}
}
gdImageDestroy(image);
gdImageDestroy(original);
if(modified) WARN("There are unsaved changes to the image.");
return(0);
}
int
res_nupdate(res_state statp, ns_updrec *rrecp_in, ns_tsig_key *key) {
ns_updrec *rrecp;
u_char answer[PACKETSZ];
u_char *packet;
struct zonegrp *zptr, tgrp;
LIST(struct zonegrp) zgrps;
int nzones = 0, nscount = 0, n;
union res_sockaddr_union nsaddrs[MAXNS];
packet = malloc(NS_MAXMSG);
if (packet == NULL) {
DPRINTF(("malloc failed"));
return (0);
}
/* Thread all of the updates onto a list of groups. */
INIT_LIST(zgrps);
memset(&tgrp, 0, sizeof (tgrp));
for (rrecp = rrecp_in; rrecp;
rrecp = LINKED(rrecp, r_link) ? NEXT(rrecp, r_link) : NULL) {
int nscnt;
/* Find the origin for it if there is one. */
tgrp.z_class = rrecp->r_class;
nscnt = res_findzonecut2(statp, rrecp->r_dname, tgrp.z_class,
RES_EXHAUSTIVE, tgrp.z_origin,
sizeof tgrp.z_origin,
tgrp.z_nsaddrs, MAXNS);
if (nscnt <= 0) {
DPRINTF(("res_findzonecut failed (%d)", nscnt));
goto done;
}
tgrp.z_nscount = nscnt;
/* Find the group for it if there is one. */
for (zptr = HEAD(zgrps); zptr != NULL; zptr = NEXT(zptr, z_link))
if (ns_samename(tgrp.z_origin, zptr->z_origin) == 1 &&
tgrp.z_class == zptr->z_class)
break;
/* Make a group for it if there isn't one. */
if (zptr == NULL) {
zptr = malloc(sizeof *zptr);
if (zptr == NULL) {
DPRINTF(("malloc failed"));
goto done;
}
*zptr = tgrp;
zptr->z_flags = 0;
INIT_LINK(zptr, z_link);
INIT_LIST(zptr->z_rrlist);
APPEND(zgrps, zptr, z_link);
}
/* Thread this rrecp onto the right group. */
APPEND(zptr->z_rrlist, rrecp, r_glink);
}
for (zptr = HEAD(zgrps); zptr != NULL; zptr = NEXT(zptr, z_link)) {
/* Construct zone section and prepend it. */
rrecp = res_mkupdrec(ns_s_zn, zptr->z_origin,
zptr->z_class, ns_t_soa, 0);
if (rrecp == NULL) {
DPRINTF(("res_mkupdrec failed"));
goto done;
}
PREPEND(zptr->z_rrlist, rrecp, r_glink);
zptr->z_flags |= ZG_F_ZONESECTADDED;
/* Marshall the update message. */
n = res_nmkupdate(statp, HEAD(zptr->z_rrlist),
packet, NS_MAXMSG);
DPRINTF(("res_mkupdate -> %d", n));
if (n < 0)
goto done;
/* Temporarily replace the resolver's nameserver set. */
nscount = res_getservers(statp, nsaddrs, MAXNS);
res_setservers(statp, zptr->z_nsaddrs, zptr->z_nscount);
/* Send the update and remember the result. */
if (key != NULL) {
#ifdef _LIBC
DPRINTF(("TSIG is not supported\n"));
RES_SET_H_ERRNO(statp, NO_RECOVERY);
goto done;
#else
n = res_nsendsigned(statp, packet, n, key,
answer, sizeof answer);
#endif
} else
n = res_nsend(statp, packet, n, answer, sizeof answer);
if (n < 0) {
DPRINTF(("res_nsend: send error, n=%d (%s)\n",
n, strerror(errno)));
goto done;
}
if (((HEADER *)answer)->rcode == NOERROR)
nzones++;
/* Restore resolver's nameserver set. */
res_setservers(statp, nsaddrs, nscount);
nscount = 0;
}
done:
while (!EMPTY(zgrps)) {
zptr = HEAD(zgrps);
if ((zptr->z_flags & ZG_F_ZONESECTADDED) != 0)
res_freeupdrec(HEAD(zptr->z_rrlist));
UNLINK(zgrps, zptr, z_link);
free(zptr);
}
if (nscount != 0)
res_setservers(statp, nsaddrs, nscount);
free(packet);
return (nzones);
}
int erl_sprint_term(char *buf, const ETERM *ep)
{
int j,i,doquote;
int ch_written = 0; /* counter of written chars */
if ((!buf) || (!ep)) return 0;
/* ASSERT(ep != NULL); */
j = i = doquote = 0;
switch(ERL_TYPE(ep))
{
case ERL_ATOM:
/* FIXME: what if some weird locale is in use? */
if (!islower((int)ERL_ATOM_PTR(ep)[0]))
doquote = 1;
for (i = 0; !doquote && i < ERL_ATOM_SIZE(ep); i++)
{
doquote = !(isalnum((int)ERL_ATOM_PTR(ep)[i])
|| (ERL_ATOM_PTR(ep)[i] == '_'));
}
if (doquote) {
*buf++ = '\'';
ch_written++;
}
{
int len = ERL_ATOM_SIZE(ep);
strncpy(buf, ERL_ATOM_PTR(ep), len);
buf += len;
ch_written += len;
}
if (doquote) {
*buf++ = '\'';
ch_written++;
}
break;
case ERL_VARIABLE:
if (!isupper((int)ERL_VAR_NAME(ep)[0])) {
doquote = 1;
*buf++ = '\'';
ch_written++;
}
len = ERL_VAR_LEN(ep);
strncpy(buf, ERL_VAR_NAME(ep), len);
buf += len;
ch_written += len;
if (doquote) {
*buf++ = '\'';
ch_written++;
}
break;
case ERL_PID:
len = sprintf(buf, "<%s.%d.%d>",
ERL_PID_NODE(ep),
ERL_PID_NUMBER(ep), ERL_PID_SERIAL(ep));
buf += len;
ch_written += len;
break;
case ERL_PORT:
len = sprintf(buf , "#Port");
buf += len;
ch_written += len;
break;
case ERL_REF:
len = sprintf(buf , "#Ref");
buf += len;
ch_written += len;
break;
case ERL_EMPTY_LIST:
len = sprintf(buf , "[]");
buf += len;
ch_written += len;
break;
case ERL_LIST:
if (is_printable_list(ep)) {
ch_written += print_string(fp, ep);
} else {
putc('[', fp);
ch_written++;
while (ERL_IS_CONS(ep)) {
ch_written += erl_sprint_term(fp, HEAD(ep));
ep = TAIL(ep);
if (ERL_IS_CONS(ep)) {
putc(',', fp);
ch_written++;
}
}
if (!ERL_IS_EMPTY_LIST(ep)) {
putc('|', fp);
ch_written++;
ch_written += erl_sprint_term(fp, ep);
}
putc(']', fp);
ch_written++;
}
break;
case ERL_TUPLE:
putc('{', fp);
ch_written++;
for (i=0; i < ERL_TUPLE_SIZE(ep); i++) {
ch_written += erl_sprint_term(fp, ERL_TUPLE_ELEMENT(ep, j++) );
if (i != ERL_TUPLE_SIZE(ep)-1) {
putc(',', fp);
ch_written++;
}
}
putc('}', fp);
ch_written++;
break;
case ERL_BINARY:
len = sprintf(buf , "#Bin");
buf += len;
ch_written += len;
break;
case ERL_INTEGER:
case ERL_SMALL_BIG:
len = sprintf(buf , "%d", ERL_INT_VALUE(ep));
buf += len;
ch_written += len;
break;
case ERL_U_INTEGER:
case ERL_U_SMALL_BIG:
len = sprintf(buf , "%d", ERL_INT_UVALUE(ep));
buf += len;
ch_written += len;
break;
case ERL_FLOAT:
len = sprintf(buf , "%f", ERL_FLOAT_VALUE(ep));
buf += len;
ch_written += len;
break;
case ERL_FUNCTION:
len = sprintf(buf , "#Fun<");
buf += len;
ch_written += len;
ch_written += erl_sprint_term(fp, ERL_FUN_MODULE(ep));
putc('.', fp);
ch_written++;
ch_written += erl_sprint_term(fp, ERL_FUN_INDEX(ep));
putc('.', fp);
ch_written++;
ch_written += erl_sprint_term(fp, ERL_FUN_UNIQ(ep));
putc('>', fp);
ch_written++;
break;
default:
ch_written = -10000;
erl_err_msg("<ERROR> erl_sprint_term: Bad type of term !");
}
return ch_written;
}
int src_v4l_set_input(src_t *src, int fd,
struct video_capability *vd,
struct video_channel *vc)
{
int count = 0, i = -1;
if(vd->channels == 0)
{
MSG("No inputs avaliable.");
return(-1);
}
if(src->list & SRC_LIST_INPUTS)
{
HEAD("--- Avaliable inputs:");
count = 0;
vc->channel = count;
while(!ioctl(fd, VIDIOCGCHAN, vc))
{
MSG("%i: %s", count, (char *) vc->name);
vc->channel = ++count;
}
}
/* If no input was specified, use input 0. */
if(!src->input)
{
MSG("No input was specified, using the first.");
count = 1;
i = 0;
}
else
{
/* Check if the input is specified by name. */
count = 0;
vc->channel = count;
while(!ioctl(fd, VIDIOCGCHAN, vc))
{
if(!strncasecmp((char *) vc->name, src->input, 32))
i = count;
vc->channel = ++count;
}
if(i == -1)
{
char *endptr;
/* Is the input specified by number? */
i = strtol(src->input, &endptr, 10);
if(endptr == src->input) i = -1;
}
}
if(i == -1 || i >= count)
{
/* The specified input wasn't found! */
ERROR("Unrecognised input \"%s\"", src->input);
return(-1);
}
/* Get data about the input channel. */
vc->channel = i;
if(ioctl(fd, VIDIOCGCHAN, vc) < 0)
{
ERROR("Error getting information for input \"%s\".",src->input);
ERROR("VIDIOCGCHAN: %s", strerror(errno));
return(-1);
}
if(src->input) DEBUG("Input %i (%s) information:", i, src->input);
else DEBUG("Input %i information:", i, src->input);
DEBUG("vc.channel=%d", vc->channel);
DEBUG("vc.name=\"%s\"", vc->name);
DEBUG("vc.tuners=%d",vc->tuners);
DEBUG("vc.flags=0x%08x", vc->flags);
if(vc->flags & VIDEO_VC_TUNER) DEBUG("- TUNER");
if(vc->flags & VIDEO_VC_AUDIO) DEBUG("- AUDIO");
DEBUG("vc.type=0x%08x", vc->type);
if(vc->type & VIDEO_TYPE_TV) DEBUG("- TV");
if(vc->type & VIDEO_TYPE_CAMERA) DEBUG("- CAMERA");
DEBUG("vc.norm=%d", vc->norm);
MSG("Setting input to %i.", i);
/* Set the source. */
if(ioctl(fd, VIDIOCSCHAN, vc) < 0)
{
ERROR("Error while setting input to %i.", i);
ERROR("VIDIOCSCHAN: %s", strerror(errno));
return(-1);
}
return(0);
}
void
isc_taskmgr_destroy(isc_taskmgr_t **managerp) {
isc_taskmgr_t *manager;
isc_task_t *task;
unsigned int i;
/*
* Destroy '*managerp'.
*/
REQUIRE(managerp != NULL);
manager = *managerp;
REQUIRE(VALID_MANAGER(manager));
#ifndef ISC_PLATFORM_USETHREADS
UNUSED(i);
if (manager->refs > 1) {
manager->refs--;
*managerp = NULL;
return;
}
#endif /* ISC_PLATFORM_USETHREADS */
XTHREADTRACE("isc_taskmgr_destroy");
/*
* Only one non-worker thread may ever call this routine.
* If a worker thread wants to initiate shutdown of the
* task manager, it should ask some non-worker thread to call
* isc_taskmgr_destroy(), e.g. by signalling a condition variable
* that the startup thread is sleeping on.
*/
/*
* Unlike elsewhere, we're going to hold this lock a long time.
* We need to do so, because otherwise the list of tasks could
* change while we were traversing it.
*
* This is also the only function where we will hold both the
* task manager lock and a task lock at the same time.
*/
LOCK(&manager->lock);
/*
* Make sure we only get called once.
*/
INSIST(!manager->exiting);
manager->exiting = ISC_TRUE;
/*
* Post shutdown event(s) to every task (if they haven't already been
* posted).
*/
for (task = HEAD(manager->tasks);
task != NULL;
task = NEXT(task, link)) {
LOCK(&task->lock);
if (task_shutdown(task))
ENQUEUE(manager->ready_tasks, task, ready_link);
UNLOCK(&task->lock);
}
#ifdef ISC_PLATFORM_USETHREADS
/*
* Wake up any sleeping workers. This ensures we get work done if
* there's work left to do, and if there are already no tasks left
* it will cause the workers to see manager->exiting.
*/
BROADCAST(&manager->work_available);
UNLOCK(&manager->lock);
/*
* Wait for all the worker threads to exit.
*/
for (i = 0; i < manager->workers; i++)
(void)isc_thread_join(manager->threads[i], NULL);
#else /* ISC_PLATFORM_USETHREADS */
/*
* Dispatch the shutdown events.
*/
UNLOCK(&manager->lock);
while (isc__taskmgr_ready())
(void)isc__taskmgr_dispatch();
INSIST(ISC_LIST_EMPTY(manager->tasks));
#endif /* ISC_PLATFORM_USETHREADS */
manager_free(manager);
*managerp = NULL;
}