自学教程：C++ CfDebug函数代码示例

static Averages *GetCurrentAverages(char *timekey){    CF_DB *dbp;    static Averages entry;    if (!OpenDB(&dbp, dbid_observations))    {        return NULL;    }    memset(&entry, 0, sizeof(entry));    AGE++;    WAGE = AGE / SECONDS_PER_WEEK * CF_MEASURE_INTERVAL;    if (ReadDB(dbp, timekey, &entry, sizeof(Averages)))    {        int i;        for (i = 0; i < CF_OBSERVABLES; i++)        {            CfDebug("Previous values (%lf,..) for time index %s/n/n", entry.Q[i].expect, timekey);        }    }    else    {        CfDebug("No previous value for time index %s/n", timekey);    }    CloseDB(dbp);    return &entry;}

Bundle *AppendBundle(Bundle **start, char *name, char *type, Rlist *args){    Bundle *bp, *lp;    CfDebug("Appending new bundle %s %s (", type, name);    if (DEBUG)    {        ShowRlist(stdout, args);    }    CfDebug(")/n");    CheckBundle(name, type);    bp = xcalloc(1, sizeof(Bundle));    if (*start == NULL)    {        *start = bp;    }    else    {        for (lp = *start; lp->next != NULL; lp = lp->next)        {        }        lp->next = bp;    }    bp->name = xstrdup(name);    bp->type = xstrdup(type);    bp->args = args;    return bp;}

long TimeAbs2Int(char *s){    time_t cftime;    int i;    char mon[4], h[3], m[3];    long month = 0, day = 0, hour = 0, min = 0, year = 0;    static long days[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };    if (s == NULL)    {        return CF_NOINT;    }    year = Str2Int(VYEAR);    if (year % 4 == 0)          /* leap years */    {        days[1] = 29;    }    if (strstr(s, ":"))         /* Hr:Min */    {        sscanf(s, "%2[^:]:%2[^:]:", h, m);        month = Month2Int(VMONTH);        day = Str2Int(VDAY);        hour = Str2Int(h);        min = Str2Int(m);    }    else                        /* date Month */    {        sscanf(s, "%3[a-zA-Z] %ld", mon, &day);        month = Month2Int(mon);        if (Month2Int(VMONTH) < month)        {            /* Wrapped around */            year--;        }    }    CfDebug("(%s)/n%ld=%s,%ld=%s,%ld,%ld,%ld/n", s, year, VYEAR, month, VMONTH, day, hour, min);    cftime = 0;    cftime += min * 60;    cftime += hour * 3600;    cftime += (day - 1) * 24 * 3600;    cftime += 24 * 3600 * ((year - 1970) / 4);  /* Leap years */    for (i = 0; i < month - 1; i++)    {        cftime += days[i] * 24 * 3600;    }    cftime += (year - 1970) * 365 * 24 * 3600;    CfDebug("Time %s CORRESPONDS %s/n", s, cf_ctime(&cftime));    return (long) cftime;}

int IsIPV6Address(char *name){    char *sp;    int count, max = 0;    CfDebug("IsIPV6Address(%s)/n", name);    if (name == NULL)    {        return false;    }    count = 0;    for (sp = name; *sp != '/0'; sp++)    {        if (isalnum((int) *sp))        {            count++;        }        else if ((*sp != ':') && (*sp != '.'))        {            return false;        }        if (*sp == 'r')        {            return false;        }        if (count > max)        {            max = count;        }        else        {            count = 0;        }    }    if (max <= 2)    {        CfDebug("Looks more like a MAC address");        return false;    }    if (strstr(name, ":") == NULL)    {        return false;    }    if (strcasestr(name, "scope"))    {        return false;    }    return true;}

void RvalDestroy(Rval rval){    Rlist *clist, *next = NULL;    CfDebug("DeleteRvalItem(%c)", rval.type);    if (DEBUG)    {        RvalShow(stdout, rval);    }    CfDebug("/n");    if (rval.item == NULL)    {        CfDebug("DeleteRval NULL/n");        return;    }    switch (rval.type)    {    case RVAL_TYPE_SCALAR:        ThreadLock(cft_lock);        free((char *) rval.item);        ThreadUnlock(cft_lock);        break;    case RVAL_TYPE_LIST:        /* rval is now a list whose first item is clist->item */        for (clist = (Rlist *) rval.item; clist != NULL; clist = next)        {            next = clist->next;            if (clist->item)            {                RvalDestroy((Rval) {clist->item, clist->type});            }            free(clist);        }        break;    case RVAL_TYPE_FNCALL:        FnCallDestroy((FnCall *) rval.item);        break;    default:        CfDebug("Nothing to do/n");        return;    }}

int ArchiveToRepository(const char *file, Attributes attr, Promise *pp, const ReportContext *report_context) /* Returns true if the file was backup up and false if not */{    char destination[CF_BUFSIZE];    struct stat sb, dsb;    if (!GetRepositoryPath(file, attr, destination))    {        return false;    }    if (attr.copy.backup == cfa_nobackup)    {        return true;    }    if (IsItemIn(VREPOSLIST, file))    {        CfOut(OUTPUT_LEVEL_INFORM, "",              "The file %s has already been moved to the repository once. Multiple update will cause loss of backup.",              file);        return true;    }    ThreadLock(cft_getaddr);    PrependItemList(&VREPOSLIST, file);    ThreadUnlock(cft_getaddr);    CfDebug("Repository(%s)/n", file);        JoinPath(destination, CanonifyName(file));    if (!MakeParentDirectory(destination, attr.move_obstructions, report_context))    {    }    if (cfstat(file, &sb) == -1)    {        CfDebug("File %s promised to archive to the repository but it disappeared!/n", file);        return true;    }    cfstat(destination, &dsb);    CheckForFileHoles(&sb, pp);    if (pp && CopyRegularFileDisk(file, destination, pp->makeholes))    {        CfOut(OUTPUT_LEVEL_INFORM, "", "Moved %s to repository location %s/n", file, destination);        return true;    }    else    {        CfOut(OUTPUT_LEVEL_INFORM, "", "Failed to move %s to repository location %s/n", file, destination);        return false;    }}

static void CheckParseReal(char *lval, char *s, const char *range){    Item *split;    double max = (double) CF_LOWINIT, min = (double) CF_HIGHINIT, val;    int n;    char output[CF_BUFSIZE];    CfDebug("/nCheckParseReal(%s => %s/%s)/n", lval, s, range);    if (s == NULL)    {        return;    }    if (strcmp(s, "inf") == 0)    {        ReportError("keyword /"inf/" has an integer value, cannot be used as real");        return;    }    if (IsCf3VarString(s))    {        CfDebug("Validation: Unable to verify syntax of real %s due to variable expansion at this stage/n", s);        return;    }/* Numeric types are registered by range separated by comma str "min,max" */    split = SplitString(range, ',');    if ((n = ListLen(split)) != 2)    {        FatalError("INTERN:format specifier for real rvalues is not ok for lval %s - %d items", lval, n);    }    sscanf(split->name, "%lf", &min);    sscanf(split->next->name, "%lf", &max);    DeleteItemList(split);    if (min == CF_HIGHINIT || max == CF_LOWINIT)    {        FatalError("INTERN:could not parse format specifier for int rvalues for lval %s", lval);    }    val = Str2Double(s);    if (val > max || val < min)    {        snprintf(output, CF_BUFSIZE,                 "Real item on rhs of lval /'%s/' give as {%s => %.3lf} is out of bounds (should be in [%s])", lval, s,                 val, range);        ReportError(output);    }    CfDebug("CheckParseReal - syntax verified/n/n");}

static int CheckParseString(char *lval, char *s, const char *range){    char output[CF_BUFSIZE];    CfDebug("/nCheckParseString(%s => %s/%s)/n", lval, s, range);    if (s == NULL)    {        return true;    }    if (strlen(range) == 0)    {        return true;    }    if (IsNakedVar(s, '@') || IsNakedVar(s, '$'))    {        CfDebug("Validation: Unable to verify variable expansion of %s at this stage/n", s);        return false;    }/* Deal with complex strings as special cases */    if (strcmp(lval, "mode") == 0 || strcmp(lval, "search_mode") == 0)    {        mode_t plus, minus;        if (!ParseModeString(s, &plus, &minus))        {            snprintf(output, CF_BUFSIZE, "Error parsing Unix permission string %s)", s);            ReportError(output);            return false;        }    }    if (FullTextMatch(range, s))    {        return true;    }    if (IsCf3VarString(s))    {        CfDebug("Validation: Unable to verify syntax of %s due to variable expansion at this stage/n", s);    }    else    {        snprintf(output, CF_BUFSIZE,                 "Scalar item in %s => { %s } in rvalue is out of bounds (value should match pattern %s)", lval, s,                 range);        ReportError(output);        return false;    }    return true;}

static SyntaxTypeMatch CheckParseInt(const char *lval, const char *s, const char *range){    Item *split;    int n;    long max = CF_LOWINIT, min = CF_HIGHINIT, val;/* Numeric types are registered by range separated by comma str "min,max" */    CfDebug("/nCheckParseInt(%s => %s/%s)/n", lval, s, range);    split = SplitString(range, ',');    if ((n = ListLen(split)) != 2)    {        ProgrammingError("INTERN: format specifier for int rvalues is not ok for lval %s - got %d items", lval, n);    }    sscanf(split->name, "%ld", &min);    if (strcmp(split->next->name, "inf") == 0)    {        max = CF_INFINITY;    }    else    {        sscanf(split->next->name, "%ld", &max);    }    DeleteItemList(split);    if (min == CF_HIGHINIT || max == CF_LOWINIT)    {        ProgrammingError("INTERN: could not parse format specifier for int rvalues for lval %s", lval);    }    if (IsCf3VarString(s))    {        return SYNTAX_TYPE_MATCH_ERROR_UNEXPANDED;    }    val = IntFromString(s);    if (val == CF_NOINT)    {        return SYNTAX_TYPE_MATCH_ERROR_INT_PARSE;    }    if (val > max || val < min)    {        return SYNTAX_TYPE_MATCH_ERROR_INT_OUT_OF_RANGE;    }    CfDebug("CheckParseInt - syntax verified/n/n");    return SYNTAX_TYPE_MATCH_OK;}

void ArgTemplate(FnCall *fp, const FnCallArg *argtemplate, Rlist *realargs){    int argnum, i;    Rlist *rp = fp->args;    char id[CF_BUFSIZE], output[CF_BUFSIZE];    const FnCallType *fn = FnCallTypeGet(fp->name);    snprintf(id, CF_MAXVARSIZE, "built-in FnCall %s-arg", fp->name);    for (argnum = 0; rp != NULL && argtemplate[argnum].pattern != NULL; argnum++)    {        if (rp->type != RVAL_TYPE_FNCALL)        {            /* Nested functions will not match to lval so don't bother checking */            SyntaxTypeMatch err = CheckConstraintTypeMatch(id, (Rval) {rp->item, rp->type}, argtemplate[argnum].dtype, argtemplate[argnum].pattern, 1);            if (err != SYNTAX_TYPE_MATCH_OK && err != SYNTAX_TYPE_MATCH_ERROR_UNEXPANDED)            {                FatalError("in %s: %s", id, SyntaxTypeMatchToString(err));            }        }        rp = rp->next;    }    if (argnum != RlistLen(realargs) && !fn->varargs)    {        snprintf(output, CF_BUFSIZE, "Argument template mismatch handling function %s(", fp->name);        RlistShow(stderr, realargs);        fprintf(stderr, ")/n");        for (i = 0, rp = realargs; i < argnum; i++)        {            printf("  arg[%d] range %s/t", i, argtemplate[i].pattern);            if (rp != NULL)            {                RvalShow(stdout, (Rval) {rp->item, rp->type});                rp = rp->next;            }            else            {                printf(" ? ");            }            printf("/n");        }        FatalError("Bad arguments");    }    for (rp = realargs; rp != NULL; rp = rp->next)    {        CfDebug("finalarg: %s/n", (char *) rp->item);    }    CfDebug("End ArgTemplate/n");}

static int SelectOwnerMatch(char *path, struct stat *lstatptr, Rlist *crit){    AlphaList leafattrib;    Rlist *rp;    char ownerName[CF_BUFSIZE];    int gotOwner;    InitAlphaList(&leafattrib);#ifndef MINGW                   // no uids on Windows    char buffer[CF_SMALLBUF];    sprintf(buffer, "%jd", (uintmax_t) lstatptr->st_uid);    PrependAlphaList(&leafattrib, buffer);#endif /* MINGW */    gotOwner = GetOwnerName(path, lstatptr, ownerName, sizeof(ownerName));    if (gotOwner)    {        PrependAlphaList(&leafattrib, ownerName);    }    else    {        PrependAlphaList(&leafattrib, "none");    }    for (rp = crit; rp != NULL; rp = rp->next)    {        if (EvalFileResult((char *) rp->item, &leafattrib))        {            CfDebug(" - ? Select owner match/n");            DeleteAlphaList(&leafattrib);            return true;        }        if (gotOwner && FullTextMatch((char *) rp->item, ownerName))        {            CfDebug(" - ? Select owner match/n");            DeleteAlphaList(&leafattrib);            return true;        }#ifndef MINGW        if (FullTextMatch((char *) rp->item, buffer))        {            CfDebug(" - ? Select owner match/n");            DeleteAlphaList(&leafattrib);            return true;        }#endif /* NOT MINGW */    }    DeleteAlphaList(&leafattrib);    return false;}

static int SelectOwnerMatch(char *path, struct stat *lstatptr, Rlist *crit){    Rlist *rp;    char ownerName[CF_BUFSIZE];    int gotOwner;    StringSet *leafattrib = StringSetNew();#ifndef __MINGW32__                   // no uids on Windows    char buffer[CF_SMALLBUF];    snprintf(buffer, CF_SMALLBUF, "%jd", (uintmax_t) lstatptr->st_uid);    StringSetAdd(leafattrib, xstrdup(buffer));#endif /* __MINGW32__ */    gotOwner = GetOwnerName(path, lstatptr, ownerName, sizeof(ownerName));    if (gotOwner)    {        StringSetAdd(leafattrib, xstrdup(ownerName));    }    else    {        StringSetAdd(leafattrib, xstrdup("none"));    }    for (rp = crit; rp != NULL; rp = rp->next)    {        if (EvalFileResult((char *) rp->item, leafattrib))        {            CfDebug(" - ? Select owner match/n");            StringSetDestroy(leafattrib);            return true;        }        if (gotOwner && (FullTextMatch((char *) rp->item, ownerName)))        {            CfDebug(" - ? Select owner match/n");            StringSetDestroy(leafattrib);            return true;        }#ifndef __MINGW32__        if (FullTextMatch((char *) rp->item, buffer))        {            CfDebug(" - ? Select owner match/n");            StringSetDestroy(leafattrib);            return true;        }#endif /* !__MINGW32__ */    }    StringSetDestroy(leafattrib);    return false;}

static void NotePerformance(char *eventname, time_t t, double value){    CF_DB *dbp;    Event e, newe;    double lastseen;    int lsea = SECONDS_PER_WEEK;    time_t now = time(NULL);    CfDebug("PerformanceEvent(%s,%.1f s)/n", eventname, value);    if (!OpenDB(&dbp, dbid_performance))    {        return;    }    if (ReadDB(dbp, eventname, &e, sizeof(e)))    {        lastseen = now - e.t;        newe.t = t;        newe.Q = QAverage(e.Q, value, 0.3);        /* Have to kickstart variance computation, assume 1% to start  */        if (newe.Q.var <= 0.0009)        {            newe.Q.var = newe.Q.expect / 100.0;        }    }    else    {        lastseen = 0.0;        newe.t = t;        newe.Q.q = value;        newe.Q.dq = 0;        newe.Q.expect = value;        newe.Q.var = 0.001;    }    if (lastseen > (double) lsea)    {        CfDebug("Performance record %s expired/n", eventname);        DeleteDB(dbp, eventname);    }    else    {        CfOut(cf_verbose, "", "Performance(%s): time=%.4lf secs, av=%.4lf +/- %.4lf/n", eventname, value, newe.Q.expect,              sqrt(newe.Q.var));        WriteDB(dbp, eventname, &newe, sizeof(newe));    }    CloseDB(dbp);}

void ArgTemplate(FnCall *fp, const FnCallArg *argtemplate, Rlist *realargs){    int argnum, i;    Rlist *rp = fp->args;    char id[CF_BUFSIZE], output[CF_BUFSIZE];    const FnCallType *fn = FindFunction(fp->name);    snprintf(id, CF_MAXVARSIZE, "built-in FnCall %s-arg", fp->name);    for (argnum = 0; rp != NULL && argtemplate[argnum].pattern != NULL; argnum++)    {        if (rp->type != CF_FNCALL)        {            /* Nested functions will not match to lval so don't bother checking */            CheckConstraintTypeMatch(id, (Rval) {rp->item, rp->type}, argtemplate[argnum].dtype, argtemplate[argnum].pattern, 1);        }        rp = rp->next;    }    if (argnum != RlistLen(realargs) && !fn->varargs)    {        snprintf(output, CF_BUFSIZE, "Argument template mismatch handling function %s(", fp->name);        ReportError(output);        ShowRlist(stderr, realargs);        fprintf(stderr, ")/n");        for (i = 0, rp = realargs; i < argnum; i++)        {            printf("  arg[%d] range %s/t", i, argtemplate[i].pattern);            if (rp != NULL)            {                ShowRval(stdout, (Rval) {rp->item, rp->type});                rp = rp->next;            }            else            {                printf(" ? ");            }            printf("/n");        }        FatalError("Bad arguments");    }    for (rp = realargs; rp != NULL; rp = rp->next)    {        CfDebug("finalarg: %s/n", (char *) rp->item);    }    CfDebug("End ArgTemplate/n");}

void GetProcessColumnNames(char *proc, char **names, int *start, int *end){    char *sp, title[16];    int col, offset = 0;    for (col = 0; col < CF_PROCCOLS; col++)    {        start[col] = end[col] = -1;        names[col] = NULL;    }    col = 0;    for (sp = proc; *sp != '/0'; sp++)    {        offset = sp - proc;        if (isspace((int) *sp))        {            if (start[col] != -1)            {                CfDebug("End of %s is %d/n", title, offset - 1);                end[col++] = offset - 1;                if (col > CF_PROCCOLS - 1)                {                    CfOut(cf_error, "", "Column overflow in process table");                    break;                }            }            continue;        }        else if (start[col] == -1)        {            start[col] = offset;            sscanf(sp, "%15s", title);            CfDebug("Start of %s is %d/n", title, offset);            names[col] = xstrdup(title);            CfDebug("Col[%d]=%s/n", col, names[col]);        }    }    if (end[col] == -1)    {        CfDebug("End of %s is %d/n", title, offset);        end[col] = offset;    }}

static int SelectGroupMatch(struct stat *lstatptr, Rlist *crit){    AlphaList leafattrib;    char buffer[CF_SMALLBUF];    struct group *gr;    Rlist *rp;    InitAlphaList(&leafattrib);    sprintf(buffer, "%jd", (uintmax_t) lstatptr->st_gid);    PrependAlphaList(&leafattrib, buffer);    if ((gr = getgrgid(lstatptr->st_gid)) != NULL)    {        PrependAlphaList(&leafattrib, gr->gr_name);    }    else    {        PrependAlphaList(&leafattrib, "none");    }    for (rp = crit; rp != NULL; rp = rp->next)    {        if (EvalFileResult((char *) rp->item, &leafattrib))        {            CfDebug(" - ? Select group match/n");            DeleteAlphaList(&leafattrib);            return true;        }        if (gr && FullTextMatch((char *) rp->item, gr->gr_name))        {            CfDebug(" - ? Select owner match/n");            DeleteAlphaList(&leafattrib);            return true;        }        if (FullTextMatch((char *) rp->item, buffer))        {            CfDebug(" - ? Select owner match/n");            DeleteAlphaList(&leafattrib);            return true;        }    }    DeleteAlphaList(&leafattrib);    return false;}

static int IsForeignFileSystem(struct stat *childstat, char *dir) /* Is FS NFS mounted ? */{    struct stat parentstat;    char vbuff[CF_BUFSIZE];    strncpy(vbuff, dir, CF_BUFSIZE - 1);    if (vbuff[strlen(vbuff) - 1] == FILE_SEPARATOR)    {        strcat(vbuff, "..");    }    else    {        strcat(vbuff, FILE_SEPARATOR_STR);        strcat(vbuff, "..");    }    if (cfstat(vbuff, &parentstat) == -1)    {        CfOut(OUTPUT_LEVEL_VERBOSE, "stat", " !! Unable to stat %s", vbuff);        return (false);    }    if (childstat->st_dev != parentstat.st_dev)    {        Rlist *rp;        Mount *entry;        CfDebug("[%s is on a different file system, not descending]/n", dir);        for (rp = MOUNTEDFSLIST; rp != NULL; rp = rp->next)        {            entry = (Mount *) rp->item;            if (!strcmp(entry->mounton, dir))            {                if ((entry->options) && (strstr(entry->options, "nfs")))                {                    return (true);                }            }        }    }    CfDebug("NotMountedFileSystem/n");    return (false);}

static SyntaxTypeMatch CheckParseOpts(const char *lval, const char *s, const char *range){    Item *split;/* List/menu types are separated by comma str "a,b,c,..." */    CfDebug("/nCheckParseOpts(%s => %s/%s)/n", lval, s, range);    if (IsNakedVar(s, '@') || IsNakedVar(s, '$'))    {        return SYNTAX_TYPE_MATCH_ERROR_UNEXPANDED;    }    split = SplitString(range, ',');    if (!IsItemIn(split, s))    {        DeleteItemList(split);        return SYNTAX_TYPE_MATCH_ERROR_OPTS_OUT_OF_RANGE;    }    DeleteItemList(split);    return SYNTAX_TYPE_MATCH_OK;}

Item *SplitStringAsItemList(const char *string, char sep) /* Splits a string containing a separator like :     into a linked list of separate items, */{    Item *liststart = NULL;    char format[9];    char node[CF_MAXVARSIZE];    CfDebug("SplitStringAsItemList(%s,%c)/n", string, sep);    sprintf(format, "%%255[^%c]", sep); /* set format string to search */    for (const char *sp = string; *sp != '/0'; sp++)    {        memset(node, 0, CF_MAXVARSIZE);        sscanf(sp, format, node);        if (strlen(node) == 0)        {            continue;        }        sp += strlen(node) - 1;        AppendItem(&liststart, node, NULL);        if (*sp == '/0')        {            break;        }    }    return liststart;}

bool IsDefinedClass(const EvalContext *ctx, const char *context, const char *ns){    ParseResult res;    if (!context)    {        return true;    }    res = ParseExpression(context, 0, strlen(context));    if (!res.result)    {        char *errexpr = HighlightExpressionError(context, res.position);        CfOut(OUTPUT_LEVEL_ERROR, "", "Unable to parse class expression: %s", errexpr);        free(errexpr);        return false;    }    else    {        ExpressionValue r = EvalExpression(ctx, res.result,                                           &EvalTokenAsClass, &EvalVarRef,                                           (void *)ns);        FreeExpression(res.result);        CfDebug("Evaluate(%s) -> %d/n", context, r);        /* r is EvalResult which could be ERROR */        return r == true;    }}

int VarClassExcluded(EvalContext *ctx, Promise *pp, char **classes){    Constraint *cp = PromiseGetConstraint(ctx, pp, "ifvarclass");    if (cp == NULL)    {        return false;    }    *classes = (char *) ConstraintGetRvalValue(ctx, "ifvarclass", pp, RVAL_TYPE_SCALAR);    if (*classes == NULL)    {        return true;    }    if (strchr(*classes, '$') || strchr(*classes, '@'))    {        CfDebug("Class expression did not evaluate");        return true;    }    if (*classes && IsDefinedClass(ctx, *classes, PromiseGetNamespace(pp)))    {        return false;    }    else    {        return true;    }}

int IsIPV4Address(char *name){    char *sp;    int count = 0;    CfDebug("IsIPV4Address(%s)/n", name);    if (name == NULL)    {        return false;    }    for (sp = name; *sp != '/0'; sp++)    {        if ((!isdigit((int) *sp)) && (*sp != '.'))        {            return false;        }        if (*sp == '.')        {            count++;        }    }    if (count != 3)    {        return false;    }    return true;}

int SendTransaction(int sd, char *buffer, int len, char status){    char work[CF_BUFSIZE];    int wlen;    memset(work, 0, sizeof(work));    if (len == 0)    {        wlen = strlen(buffer);    }    else    {        wlen = len;    }    if (wlen > CF_BUFSIZE - CF_INBAND_OFFSET)    {        CfOut(cf_error, "", "SendTransaction: wlen (%d) > %d - %d", wlen, CF_BUFSIZE, CF_INBAND_OFFSET);        FatalError("SendTransaction software failure");    }    snprintf(work, CF_INBAND_OFFSET, "%c %d", status, wlen);    memcpy(work + CF_INBAND_OFFSET, buffer, wlen);    CfDebug("Transaction Send[%s][Packed text]/n", work);    if (SendSocketStream(sd, work, wlen + CF_INBAND_OFFSET, 0) == -1)    {        return -1;    }    return 0;}

void HashString(const char *buffer, int len, unsigned char digest[EVP_MAX_MD_SIZE + 1], enum cfhashes type){    EVP_MD_CTX context;    const EVP_MD *md = NULL;    int md_len;    CfDebug("HashString(%c)/n", type);    switch (type)    {    case cf_crypt:        CfOut(OUTPUT_LEVEL_ERROR, "", "The crypt support is not presently implemented, please use another algorithm instead");        memset(digest, 0, EVP_MAX_MD_SIZE + 1);        break;    default:        md = EVP_get_digestbyname(FileHashName(type));        if (md == NULL)        {            CfOut(OUTPUT_LEVEL_INFORM, "", " !! Digest type %s not supported by OpenSSL library", CF_DIGEST_TYPES[type][0]);        }        EVP_DigestInit(&context, md);        EVP_DigestUpdate(&context, (unsigned char *) buffer, (size_t) len);        EVP_DigestFinal(&context, digest, &md_len);        break;    }}

void HashFile(char *filename, unsigned char digest[EVP_MAX_MD_SIZE + 1], enum cfhashes type){    FILE *file;    EVP_MD_CTX context;    int len, md_len;    unsigned char buffer[1024];    const EVP_MD *md = NULL;    CfDebug("HashFile(%d,%s)/n", type, filename);    if ((file = fopen(filename, "rb")) == NULL)    {        CfOut(OUTPUT_LEVEL_INFORM, "fopen", "%s can't be opened/n", filename);    }    else    {        md = EVP_get_digestbyname(FileHashName(type));        EVP_DigestInit(&context, md);        while ((len = fread(buffer, 1, 1024, file)))        {            EVP_DigestUpdate(&context, buffer, len);        }        EVP_DigestFinal(&context, digest, &md_len);        /* Digest length stored in md_len */        fclose(file);    }}

int CheckParseClass(char *lval, char *s, const char *range){    char output[CF_BUFSIZE];    if (s == NULL)    {        return false;    }    CfDebug("/nCheckParseClass(%s => %s/%s)/n", lval, s, range);    if (strlen(range) == 0)    {        return true;    }    if (FullTextMatch(range, s))    {        return true;    }    snprintf(output, CF_BUFSIZE, "Class item on rhs of lval /'%s/' given as { %s } is out of bounds (should match %s)",             lval, s, range);    ReportError(output);    return false;}

Rlist *RlistFromSplitString(const char *string, char sep) /* Splits a string containing a separator like ","     into a linked list of separate items, supports    escaping separators, e.g. /, */{    if (string == NULL)    {        return NULL;    }    Rlist *liststart = NULL;    char node[CF_MAXVARSIZE];    int maxlen = strlen(string);    CfDebug("SplitStringAsRList(%s)/n", string);    for (const char *sp = string; *sp != '/0'; sp++)    {        if (*sp == '/0' || sp > string + maxlen)        {            break;        }        memset(node, 0, CF_MAXVARSIZE);        sp += SubStrnCopyChr(node, sp, CF_MAXVARSIZE, sep);        RlistAppendScalar(&liststart, node);    }    return liststart;}

static void KeepPromises(Policy *policy, const ReportContext *report_context){    Constraint *cp;    Rval retval;    for (cp = ControlBodyConstraints(policy, cf_monitor); cp != NULL; cp = cp->next)    {        if (IsExcluded(cp->classes, NULL))        {            continue;        }        if (GetVariable("control_monitor", cp->lval, &retval) == cf_notype)        {            CfOut(cf_error, "", "Unknown lval %s in monitor control body", cp->lval);            continue;        }        if (strcmp(cp->lval, CFM_CONTROLBODY[cfm_histograms].lval) == 0)        {            /* Keep accepting this option for backward compatibility. */        }        if (strcmp(cp->lval, CFM_CONTROLBODY[cfm_tcpdump].lval) == 0)        {            MonNetworkSnifferEnable(GetBoolean(retval.item));        }        if (strcmp(cp->lval, CFM_CONTROLBODY[cfm_forgetrate].lval) == 0)        {            sscanf(retval.item, "%lf", &FORGETRATE);            CfDebug("forget rate = %f/n", FORGETRATE);        }    }}

void NewScalar(const char *scope, const char *lval, const char *rval, enum cfdatatype dt){    Rval rvald;    Scope *ptr;    CfDebug("NewScalar(%s,%s,%s)/n", scope, lval, rval);    ptr = GetScope(scope);    if (ptr == NULL)    {        CfOut(cf_error, "", "!! Attempt to add variable /"%s/" to non-existant scope /"%s/" - ignored", lval, scope);        return;    }// Newscalar allocates memory through NewAssoc    if (GetVariable(scope, lval, &rvald) != cf_notype)    {        DeleteScalar(scope, lval);    }/* * We know AddVariableHash does not change passed Rval structure or its * contents, but we have no easy way to express it in C type system, hence cast. */    AddVariableHash(scope, lval, (Rval) {(char *) rval, CF_SCALAR}, dt, NULL, 0);}

static int Dialogue(int sd, char *s){    int sent;    char ch, f = '/0';    int charpos, rfclinetype = ' ';    if ((s != NULL) && (*s != '/0'))    {        sent = send(sd, s, strlen(s), 0);        CfDebug("SENT(%d)->%s", sent, s);    }    else    {        CfDebug("Nothing to send .. waiting for opening/n");    }    charpos = 0;    while (recv(sd, &ch, 1, 0))    {        charpos++;        if (f == '/0')        {            f = ch;        }        if (charpos == 4)       /* Multiline RFC in form 222-Message with hyphen at pos 4 */        {            rfclinetype = ch;        }        CfDebug("%c", ch);        if ((ch == '/n') || (ch == '/0'))        {            charpos = 0;            if (rfclinetype == ' ')            {                break;            }        }    }    return ((f == '2') || (f == '3'));  /* return code 200 or 300 from smtp */}