Annotation of src/usr.bin/rdist/message.c, Revision 1.1
1.1 ! dm 1: /*
! 2: * Copyright (c) 1983 Regents of the University of California.
! 3: * All rights reserved.
! 4: *
! 5: * Redistribution and use in source and binary forms, with or without
! 6: * modification, are permitted provided that the following conditions
! 7: * are met:
! 8: * 1. Redistributions of source code must retain the above copyright
! 9: * notice, this list of conditions and the following disclaimer.
! 10: * 2. Redistributions in binary form must reproduce the above copyright
! 11: * notice, this list of conditions and the following disclaimer in the
! 12: * documentation and/or other materials provided with the distribution.
! 13: * 3. All advertising materials mentioning features or use of this software
! 14: * must display the following acknowledgement:
! 15: * This product includes software developed by the University of
! 16: * California, Berkeley and its contributors.
! 17: * 4. Neither the name of the University nor the names of its contributors
! 18: * may be used to endorse or promote products derived from this software
! 19: * without specific prior written permission.
! 20: *
! 21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 31: * SUCH DAMAGE.
! 32: */
! 33:
! 34: #ifndef lint
! 35: static char RCSid[] =
! 36: "$Id: message.c,v 6.22 1995/12/11 23:37:35 mcooper Exp $";
! 37:
! 38: static char sccsid[] = "@(#)common.c";
! 39:
! 40: static char copyright[] =
! 41: "@(#) Copyright (c) 1983 Regents of the University of California.\n\
! 42: All rights reserved.\n";
! 43: #endif /* !lint */
! 44:
! 45: /*
! 46: * Message handling functions for both rdist and rdistd.
! 47: */
! 48:
! 49: #include "defs.h"
! 50:
! 51: #define MSGBUFSIZ 32*1024
! 52:
! 53: int debug = 0; /* Debugging level */
! 54: int nerrs = 0; /* Number of errors */
! 55: char *tempfile = NULL; /* Name of temporary file */
! 56:
! 57: /*
! 58: * Message Types
! 59: */
! 60: MSGTYPE msgtypes[] = {
! 61: { MT_CHANGE, "change" },
! 62: { MT_INFO, "info" },
! 63: { MT_NOTICE, "notice" },
! 64: { MT_NERROR, "nerror" },
! 65: { MT_FERROR, "ferror" },
! 66: { MT_WARNING, "warning" },
! 67: { MT_VERBOSE, "verbose" },
! 68: { MT_ALL, "all" },
! 69: { MT_DEBUG, "debug" },
! 70: { 0 },
! 71: };
! 72:
! 73: static void msgsendstdout(), msgsendfile(), msgsendsyslog(),
! 74: msgsendnotify();
! 75:
! 76: /*
! 77: * Message Facilities
! 78: */
! 79: MSGFACILITY msgfacility[] = {
! 80: { MF_STDOUT, "stdout", msgsendstdout },
! 81: { MF_FILE, "file", msgsendfile },
! 82: { MF_SYSLOG, "syslog", msgsendsyslog },
! 83: { MF_NOTIFY, "notify", msgsendnotify },
! 84: { 0 },
! 85: };
! 86:
! 87: /*
! 88: * Print message logging usage message
! 89: */
! 90: extern void msgprusage()
! 91: {
! 92: register int i, x;
! 93:
! 94: (void) fprintf(stderr, "\nWhere <msgopt> is of form\n");
! 95: (void) fprintf(stderr,
! 96: "\t<facility1>=<type1>,<type2>,...:<facility2>=<type1>,<type2>...\n");
! 97:
! 98: (void) fprintf(stderr, "Valid <facility> names:");
! 99:
! 100: for (i = 0; msgfacility[i].mf_name; ++i)
! 101: (void) fprintf(stderr, " %s", msgfacility[i].mf_name);
! 102:
! 103: (void) fprintf(stderr, "\nValid <type> names:");
! 104: for (x = 0; msgtypes[x].mt_name; ++x)
! 105: (void) fprintf(stderr, " %s", msgtypes[x].mt_name);
! 106:
! 107: (void) fprintf(stderr, "\n");
! 108: }
! 109:
! 110: /*
! 111: * Print enabled message logging info
! 112: */
! 113: extern void msgprconfig()
! 114: {
! 115: register int i, x;
! 116: static char buf[MSGBUFSIZ];
! 117:
! 118: debugmsg(DM_MISC, "Current message logging config:");
! 119: for (i = 0; msgfacility[i].mf_name; ++i) {
! 120: (void) sprintf(buf, " %s=", msgfacility[i].mf_name);
! 121: for (x = 0; msgtypes[x].mt_name; ++x)
! 122: if (IS_ON(msgfacility[i].mf_msgtypes,
! 123: msgtypes[x].mt_type)) {
! 124: if (x > 0)
! 125: (void) strcat(buf, ",");
! 126: (void) strcat(buf, msgtypes[x].mt_name);
! 127: }
! 128: debugmsg(DM_MISC, "%s", buf);
! 129: }
! 130:
! 131: }
! 132:
! 133: /*
! 134: * Get the Message Facility entry "name"
! 135: */
! 136: static MSGFACILITY *getmsgfac(name)
! 137: char *name;
! 138: {
! 139: register int i;
! 140:
! 141: for (i = 0; msgfacility[i].mf_name; ++i)
! 142: if (strcasecmp(name, msgfacility[i].mf_name) == 0)
! 143: return(&msgfacility[i]);
! 144:
! 145: return((MSGFACILITY *) NULL);
! 146: }
! 147:
! 148: /*
! 149: * Get the Message Type entry named "name"
! 150: */
! 151: static MSGTYPE *getmsgtype(name)
! 152: char *name;
! 153: {
! 154: register int i;
! 155:
! 156: for (i = 0; msgtypes[i].mt_name; ++i)
! 157: if (strcasecmp(name, msgtypes[i].mt_name) == 0)
! 158: return(&msgtypes[i]);
! 159:
! 160: return((MSGTYPE *) NULL);
! 161: }
! 162:
! 163: /*
! 164: * Set Message Type information for Message Facility "msgfac" as
! 165: * indicated by string "str".
! 166: */
! 167: static char *setmsgtypes(msgfac, str)
! 168: MSGFACILITY *msgfac;
! 169: char *str;
! 170: {
! 171: static char ebuf[BUFSIZ];
! 172: register char *cp;
! 173: register char *strptr, *word;
! 174: register MSGTYPE *mtp;
! 175:
! 176: /*
! 177: * MF_SYSLOG is the only supported message facility for the server
! 178: */
! 179: if (isserver && (msgfac->mf_msgfac != MF_SYSLOG &&
! 180: msgfac->mf_msgfac != MF_FILE)) {
! 181: (void) sprintf(ebuf,
! 182: "The \"%s\" message facility cannot be used by the server.",
! 183: msgfac->mf_name);
! 184: return(ebuf);
! 185: }
! 186:
! 187: strptr = str;
! 188:
! 189: /*
! 190: * Do any necessary Message Facility preparation
! 191: */
! 192: switch(msgfac->mf_msgfac) {
! 193: case MF_FILE:
! 194: /*
! 195: * The MF_FILE string should look like "<file>=<types>".
! 196: */
! 197: if ((cp = strchr(strptr, '=')) == NULL)
! 198: return(
! 199: "No file name found for \"file\" message facility");
! 200: *cp++ = CNULL;
! 201:
! 202: if ((msgfac->mf_fptr = fopen(strptr, "w")) == NULL)
! 203: fatalerr("Cannot open log file for writing: %s: %s.",
! 204: strptr, SYSERR);
! 205: msgfac->mf_filename = strdup(strptr);
! 206:
! 207: strptr = cp;
! 208: break;
! 209:
! 210: case MF_NOTIFY:
! 211: break;
! 212:
! 213: case MF_STDOUT:
! 214: msgfac->mf_fptr = stdout;
! 215: break;
! 216:
! 217: case MF_SYSLOG:
! 218: #if defined(LOG_OPTS)
! 219: #if defined(LOG_FACILITY)
! 220: openlog(progname, LOG_OPTS, LOG_FACILITY);
! 221: #else
! 222: openlog(progname, LOG_OPTS);
! 223: #endif /* LOG_FACILITY */
! 224: #endif /* LOG_OPTS */
! 225: break;
! 226: }
! 227:
! 228: /*
! 229: * Parse each type word
! 230: */
! 231: msgfac->mf_msgtypes = 0; /* Start from scratch */
! 232: while (strptr) {
! 233: word = strptr;
! 234: if (cp = strchr(strptr, ','))
! 235: *cp++ = CNULL;
! 236: strptr = cp;
! 237:
! 238: if (mtp = getmsgtype(word)) {
! 239: msgfac->mf_msgtypes |= mtp->mt_type;
! 240: /*
! 241: * XXX This is really a kludge until we add real
! 242: * control over debugging.
! 243: */
! 244: if (!debug && isserver &&
! 245: strcasecmp(word, "debug") == 0)
! 246: debug = DM_ALL;
! 247: } else {
! 248: (void) sprintf(ebuf, "Message type \"%s\" is invalid.",
! 249: word);
! 250: return(ebuf);
! 251: }
! 252: }
! 253:
! 254: return((char *) NULL);
! 255: }
! 256:
! 257: /*
! 258: * Parse a message logging option string
! 259: */
! 260: extern char *msgparseopts(msgstr, doset)
! 261: char *msgstr;
! 262: int doset;
! 263: {
! 264: static char ebuf[BUFSIZ], msgbuf[MSGBUFSIZ];
! 265: register char *cp, *optstr;
! 266: register char *word;
! 267: MSGFACILITY *msgfac;
! 268:
! 269: if (msgstr == NULL)
! 270: return("NULL message string");
! 271:
! 272: /* strtok() is harmful */
! 273: (void) strcpy(msgbuf, msgstr);
! 274:
! 275: /*
! 276: * Each <facility>=<types> list is seperated by ":".
! 277: */
! 278: for (optstr = strtok(msgbuf, ":"); optstr;
! 279: optstr = strtok((char *)NULL, ":")) {
! 280:
! 281: if ((cp = strchr(optstr, '=')) == NULL)
! 282: return("No '=' found");
! 283:
! 284: *cp++ = CNULL;
! 285: word = optstr;
! 286: if ((int)strlen(word) <= 0)
! 287: return("No message facility specified");
! 288: if ((int)strlen(cp) <= 0)
! 289: return("No message type specified");
! 290:
! 291: if ((msgfac = getmsgfac(word)) == NULL) {
! 292: (void) sprintf(ebuf,
! 293: "%s is not a valid message facility",
! 294: word);
! 295: return(ebuf);
! 296: }
! 297:
! 298: if (doset) {
! 299: char *mcp;
! 300:
! 301: if (mcp = setmsgtypes(msgfac, cp))
! 302: return(mcp);
! 303: }
! 304: }
! 305:
! 306: if (isserver && debug) {
! 307: debugmsg(DM_MISC, "%s", getversion());
! 308: msgprconfig();
! 309: }
! 310:
! 311: return((char *) NULL);
! 312: }
! 313:
! 314: /*
! 315: * Send a message to facility "stdout".
! 316: * For rdistd, this is really the rdist client.
! 317: */
! 318: static void msgsendstdout(msgfac, mtype, flags, msgbuf)
! 319: /*ARGSUSED*/
! 320: MSGFACILITY *msgfac;
! 321: int mtype;
! 322: int flags;
! 323: char *msgbuf;
! 324: {
! 325: char cmd;
! 326:
! 327: if (isserver) {
! 328: if (rem_w < 0 || IS_ON(flags, MT_NOREMOTE))
! 329: return;
! 330:
! 331: cmd = CNULL;
! 332:
! 333: switch(mtype) {
! 334: case MT_NERROR: cmd = C_ERRMSG; break;
! 335: case MT_FERROR: cmd = C_FERRMSG; break;
! 336: case MT_NOTICE: cmd = C_NOTEMSG; break;
! 337: case MT_REMOTE: cmd = C_LOGMSG; break;
! 338: }
! 339:
! 340: if (cmd != CNULL)
! 341: (void) sendcmd(cmd, "%s", msgbuf);
! 342: } else {
! 343: switch(mtype) {
! 344: case MT_FERROR:
! 345: case MT_NERROR:
! 346: if (msgbuf && *msgbuf) {
! 347: (void) fprintf(stderr, "%s\n", msgbuf);
! 348: (void) fflush(stderr);
! 349: }
! 350: break;
! 351:
! 352: case MT_DEBUG:
! 353: /*
! 354: * Only things that are strictly MT_DEBUG should
! 355: * be shown.
! 356: */
! 357: if (flags != MT_DEBUG)
! 358: return;
! 359: case MT_NOTICE:
! 360: case MT_CHANGE:
! 361: case MT_INFO:
! 362: case MT_VERBOSE:
! 363: case MT_WARNING:
! 364: if (msgbuf && *msgbuf) {
! 365: (void) printf("%s\n", msgbuf);
! 366: (void) fflush(stdout);
! 367: }
! 368: break;
! 369: }
! 370: }
! 371: }
! 372:
! 373: /*
! 374: * Send a message to facility "syslog"
! 375: */
! 376: static void msgsendsyslog(msgfac, mtype, flags, msgbuf)
! 377: /*ARGSUSED*/
! 378: MSGFACILITY *msgfac;
! 379: int mtype;
! 380: int flags;
! 381: char *msgbuf;
! 382: {
! 383: int syslvl = 0;
! 384:
! 385: if (!msgbuf || !*msgbuf)
! 386: return;
! 387:
! 388: switch(mtype) {
! 389: #if defined(SL_NERROR)
! 390: case MT_NERROR: syslvl = SL_NERROR; break;
! 391: #endif
! 392: #if defined(SL_FERROR)
! 393: case MT_FERROR: syslvl = SL_FERROR; break;
! 394: #endif
! 395: #if defined(SL_WARNING)
! 396: case MT_WARNING: syslvl = SL_WARNING; break;
! 397: #endif
! 398: #if defined(SL_CHANGE)
! 399: case MT_CHANGE: syslvl = SL_CHANGE; break;
! 400: #endif
! 401: #if defined(SL_INFO)
! 402: case MT_SYSLOG:
! 403: case MT_VERBOSE:
! 404: case MT_INFO: syslvl = SL_INFO; break;
! 405: #endif
! 406: #if defined(SL_NOTICE)
! 407: case MT_NOTICE: syslvl = SL_NOTICE; break;
! 408: #endif
! 409: #if defined(SL_DEBUG)
! 410: case MT_DEBUG: syslvl = SL_DEBUG; break;
! 411: #endif
! 412: }
! 413:
! 414: if (syslvl)
! 415: syslog(syslvl, "%s", msgbuf);
! 416: }
! 417:
! 418: /*
! 419: * Send a message to a "file" facility.
! 420: */
! 421: static void msgsendfile(msgfac, mtype, flags, msgbuf)
! 422: /*ARGSUSED*/
! 423: MSGFACILITY *msgfac;
! 424: int mtype;
! 425: int flags;
! 426: char *msgbuf;
! 427: {
! 428: if (msgfac->mf_fptr == NULL)
! 429: return;
! 430:
! 431: if (!msgbuf || !*msgbuf)
! 432: return;
! 433:
! 434: (void) fprintf(msgfac->mf_fptr, "%s\n", msgbuf);
! 435: (void) fflush(msgfac->mf_fptr);
! 436: }
! 437:
! 438: /*
! 439: * Same method as msgsendfile()
! 440: */
! 441: static void msgsendnotify(msgfac, mtype, flags, msgbuf)
! 442: /*ARGSUSED*/
! 443: MSGFACILITY *msgfac;
! 444: int mtype;
! 445: int flags;
! 446: char *msgbuf;
! 447: {
! 448: if (IS_ON(flags, MT_DEBUG))
! 449: return;
! 450:
! 451: if (!msgbuf || !*msgbuf)
! 452: return;
! 453:
! 454: if (!msgfac->mf_fptr) {
! 455: register char *cp;
! 456: char *getenv();
! 457:
! 458: /*
! 459: * Create and open a new temporary file
! 460: */
! 461: if ((cp = getenv("TMPDIR")) == (char *) NULL)
! 462: cp = _PATH_TMP;
! 463: tempfile = (char *) xmalloc(strlen(cp) + 1 +
! 464: strlen(_RDIST_TMP) + 2);
! 465: (void) sprintf(tempfile, "%s/%s", cp, _RDIST_TMP);
! 466:
! 467: msgfac->mf_filename = tempfile;
! 468: (void) mktemp(msgfac->mf_filename);
! 469: if ((msgfac->mf_fptr = fopen(msgfac->mf_filename, "w"))==NULL)
! 470: fatalerr("Cannot open notify file for writing: %s: %s.",
! 471: msgfac->mf_filename, SYSERR);
! 472: debugmsg(DM_MISC, "Created notify temp file '%s'",
! 473: msgfac->mf_filename);
! 474: }
! 475:
! 476: if (msgfac->mf_fptr == NULL)
! 477: return;
! 478:
! 479: (void) fprintf(msgfac->mf_fptr, "%s\n", msgbuf);
! 480: (void) fflush(msgfac->mf_fptr);
! 481: }
! 482:
! 483: /*
! 484: * Insure currenthost is set to something reasonable.
! 485: */
! 486: extern void checkhostname()
! 487: {
! 488: static char mbuf[MAXHOSTNAMELEN];
! 489: char *cp;
! 490:
! 491: if (!currenthost) {
! 492: if (gethostname(mbuf, sizeof(mbuf)) == 0) {
! 493: if ((cp = strchr(mbuf, '.')) != NULL)
! 494: *cp = CNULL;
! 495: currenthost = strdup(mbuf);
! 496: } else
! 497: currenthost = "(unknown)";
! 498: }
! 499: }
! 500:
! 501: /*
! 502: * Print a message contained in "msgbuf" if a level "lvl" is set.
! 503: */
! 504: static void _message(flags, msgbuf)
! 505: int flags;
! 506: char *msgbuf;
! 507: {
! 508: register int i, x;
! 509: register char *cp;
! 510: static char mbuf[2048];
! 511:
! 512: if (msgbuf && *msgbuf) {
! 513: /*
! 514: * Ensure no stray newlines are present
! 515: */
! 516: if (cp = strchr(msgbuf, '\n'))
! 517: *cp = CNULL;
! 518:
! 519: checkhostname();
! 520: if (strncmp(currenthost, msgbuf, strlen(currenthost)) == 0)
! 521: (void) strcpy(mbuf, msgbuf);
! 522: else
! 523: (void) sprintf(mbuf, "%s: %s", currenthost, msgbuf);
! 524: } else
! 525: (void) strcpy(mbuf, "");
! 526:
! 527: /*
! 528: * Special case for messages that only get
! 529: * logged to the system log facility
! 530: */
! 531: if (IS_ON(flags, MT_SYSLOG)) {
! 532: msgsendsyslog((MSGFACILITY *)NULL, MT_SYSLOG, flags, mbuf);
! 533: return;
! 534: }
! 535:
! 536: /*
! 537: * Special cases
! 538: */
! 539: if (isserver && IS_ON(flags, MT_REMOTE))
! 540: msgsendstdout((MSGFACILITY *)NULL, MT_REMOTE, flags, mbuf);
! 541: else if (isserver && IS_ON(flags, MT_NERROR))
! 542: msgsendstdout((MSGFACILITY *)NULL, MT_NERROR, flags, mbuf);
! 543: else if (isserver && IS_ON(flags, MT_FERROR))
! 544: msgsendstdout((MSGFACILITY *)NULL, MT_FERROR, flags, mbuf);
! 545: else if (isserver && IS_ON(flags, MT_NOTICE)) {
! 546: msgsendstdout((MSGFACILITY *)NULL, MT_NOTICE, flags, mbuf);
! 547: return;
! 548: }
! 549:
! 550: /*
! 551: * For each Message Facility, check each Message Type to see
! 552: * if the bits in "flags" are set. If so, call the appropriate
! 553: * Message Facility to dispatch the message.
! 554: */
! 555: for (i = 0; msgfacility[i].mf_name; ++i)
! 556: for (x = 0; msgtypes[x].mt_name; ++x)
! 557: /*
! 558: * XXX MT_ALL should not be used directly
! 559: */
! 560: if (msgtypes[x].mt_type != MT_ALL &&
! 561: IS_ON(flags, msgtypes[x].mt_type) &&
! 562: IS_ON(msgfacility[i].mf_msgtypes,
! 563: msgtypes[x].mt_type))
! 564: (*msgfacility[i].mf_sendfunc)(&msgfacility[i],
! 565: msgtypes[x].mt_type,
! 566: flags,
! 567: mbuf);
! 568: }
! 569:
! 570: #if defined(ARG_TYPE) && ARG_TYPE == ARG_VARARGS
! 571: /*
! 572: * Varargs front-end to _message()
! 573: */
! 574: extern void message(va_alist)
! 575: va_dcl
! 576: {
! 577: static char buf[MSGBUFSIZ];
! 578: va_list args;
! 579: char *fmt;
! 580: int lvl;
! 581:
! 582: va_start(args);
! 583: lvl = (int) va_arg(args, int);
! 584: fmt = (char *) va_arg(args, char *);
! 585: va_end(args);
! 586:
! 587: (void) vsprintf(buf, fmt, args);
! 588:
! 589: _message(lvl, buf);
! 590: }
! 591: #endif /* ARG_VARARGS */
! 592:
! 593: #if defined(ARG_TYPE) && ARG_TYPE == ARG_STDARG
! 594: /*
! 595: * Stdarg front-end to _message()
! 596: */
! 597: extern void message(int lvl, char *fmt, ...)
! 598: {
! 599: static char buf[MSGBUFSIZ];
! 600: va_list args;
! 601:
! 602: va_start(args, fmt);
! 603: (void) vsprintf(buf, fmt, args);
! 604: va_end(args);
! 605:
! 606: _message(lvl, buf);
! 607: }
! 608: #endif /* ARG_STDARG */
! 609:
! 610:
! 611: #if !defined(ARG_TYPE)
! 612: /*
! 613: * Simple front-end to _message()
! 614: */
! 615: /*VARARGS2*/
! 616: extern void message(lvl, fmt, a1, a2, a3, a4, a5)
! 617: int lvl;
! 618: char *fmt;
! 619: {
! 620: static char buf[MSGBUFSIZ];
! 621:
! 622: (void) sprintf(buf, fmt, a1, a2, a3, a4, a5);
! 623:
! 624: _message(lvl, buf);
! 625: }
! 626: #endif /* !ARG_TYPE */
! 627:
! 628: /*
! 629: * Display a debugging message
! 630: */
! 631: static void _debugmsg(lvl, buf)
! 632: int lvl;
! 633: char *buf;
! 634: {
! 635: if (IS_ON(debug, lvl))
! 636: _message(MT_DEBUG, buf);
! 637: }
! 638:
! 639: #if defined(ARG_TYPE) && ARG_TYPE == ARG_VARARGS
! 640: /*
! 641: * Varargs front-end to _debugmsg()
! 642: */
! 643: extern void debugmsg(va_alist)
! 644: va_dcl
! 645: {
! 646: static char buf[MSGBUFSIZ];
! 647: va_list args;
! 648: char *fmt;
! 649: int lvl;
! 650:
! 651: va_start(args);
! 652: lvl = (int) va_arg(args, int);
! 653: fmt = (char *) va_arg(args, char *);
! 654: va_end(args);
! 655:
! 656: (void) vsprintf(buf, fmt, args);
! 657:
! 658: _debugmsg(lvl, buf);
! 659: }
! 660: #endif /* ARG_VARARGS */
! 661:
! 662: #if defined(ARG_TYPE) && ARG_TYPE == ARG_STDARG
! 663: /*
! 664: * Stdarg front-end to _debugmsg()
! 665: */
! 666: extern void debugmsg(int lvl, char *fmt, ...)
! 667: {
! 668: static char buf[MSGBUFSIZ];
! 669: va_list args;
! 670:
! 671: va_start(args, fmt);
! 672: (void) vsprintf(buf, fmt, args);
! 673: va_end(args);
! 674:
! 675: _debugmsg(lvl, buf);
! 676: }
! 677: #endif /* ARG_STDARG */
! 678:
! 679: #if !defined(ARG_TYPE)
! 680: /*
! 681: * Simple front-end to _debugmsg()
! 682: */
! 683: /*VARARGS2*/
! 684: extern void debugmsg(lvl, fmt, a1, a2, a3, a4, a5)
! 685: int lvl;
! 686: char *fmt;
! 687: {
! 688: static char buf[MSGBUFSIZ];
! 689:
! 690: (void) sprintf(buf, fmt, a1, a2, a3, a4, a5);
! 691:
! 692: _debugmsg(lvl, buf);
! 693: }
! 694: #endif /* ARG_TYPE */
! 695:
! 696: /*
! 697: * Print an error message
! 698: */
! 699: static void _error(msg)
! 700: char *msg;
! 701: {
! 702: static char buf[MSGBUFSIZ];
! 703:
! 704: nerrs++;
! 705: buf[0] = CNULL;
! 706:
! 707: if (msg) {
! 708: if (isserver)
! 709: (void) sprintf(buf, "REMOTE ERROR: %s", msg);
! 710: else
! 711: (void) sprintf(buf, "LOCAL ERROR: %s", msg);
! 712: }
! 713:
! 714: _message(MT_NERROR, (buf[0]) ? buf : NULL);
! 715: }
! 716:
! 717: #if defined(ARG_TYPE) && ARG_TYPE == ARG_VARARGS
! 718: /*
! 719: * Varargs frontend to _error()
! 720: */
! 721: extern void error(va_alist)
! 722: va_dcl
! 723: {
! 724: static char buf[MSGBUFSIZ];
! 725: va_list args;
! 726: char *fmt;
! 727:
! 728: buf[0] = CNULL;
! 729: va_start(args);
! 730: fmt = (char *) va_arg(args, char *);
! 731: if (fmt)
! 732: (void) vsprintf(buf, fmt, args);
! 733: va_end(args);
! 734:
! 735: _error((buf[0]) ? buf : NULL);
! 736: }
! 737: #endif /* ARG_VARARGS */
! 738:
! 739: #if defined(ARG_TYPE) && ARG_TYPE == ARG_STDARG
! 740: /*
! 741: * Stdarg frontend to _error()
! 742: */
! 743: extern void error(char *fmt, ...)
! 744: {
! 745: static char buf[MSGBUFSIZ];
! 746: va_list args;
! 747:
! 748: buf[0] = CNULL;
! 749: va_start(args, fmt);
! 750: if (fmt)
! 751: (void) vsprintf(buf, fmt, args);
! 752: va_end(args);
! 753:
! 754: _error((buf[0]) ? buf : NULL);
! 755: }
! 756: #endif /* ARG_STDARG */
! 757:
! 758: #if !defined(ARG_TYPE)
! 759: /*
! 760: * Simple frontend to _error()
! 761: */
! 762: /*VARARGS1*/
! 763: extern void error(fmt, a1, a2, a3, a4, a5, a6)
! 764: char *fmt;
! 765: {
! 766: static char buf[MSGBUFSIZ];
! 767:
! 768: buf[0] = CNULL;
! 769: if (fmt)
! 770: (void) sprintf(buf, fmt, a1, a2, a3, a4, a5, a6);
! 771:
! 772: _error((buf[0]) ? buf : NULL);
! 773: }
! 774: #endif /* ARG_TYPE */
! 775:
! 776: /*
! 777: * Display a fatal message
! 778: */
! 779: static void _fatalerr(msg)
! 780: char *msg;
! 781: {
! 782: static char buf[MSGBUFSIZ];
! 783:
! 784: ++nerrs;
! 785:
! 786: if (isserver)
! 787: (void) sprintf(buf, "REMOTE ERROR: %s", msg);
! 788: else
! 789: (void) sprintf(buf, "LOCAL ERROR: %s", msg);
! 790:
! 791: _message(MT_FERROR, buf);
! 792:
! 793: exit(nerrs);
! 794: }
! 795:
! 796: #if defined(ARG_TYPE) && ARG_TYPE == ARG_VARARGS
! 797: /*
! 798: * Varargs front-end to _fatalerr()
! 799: */
! 800: extern void fatalerr(va_alist)
! 801: va_dcl
! 802: {
! 803: static char buf[MSGBUFSIZ];
! 804: va_list args;
! 805: char *fmt;
! 806:
! 807: va_start(args);
! 808: fmt = (char *) va_arg(args, char *);
! 809: (void) vsprintf(buf, fmt, args);
! 810: va_end(args);
! 811:
! 812: _fatalerr(buf);
! 813: }
! 814: #endif /* ARG_VARARGS */
! 815:
! 816: #if defined(ARG_TYPE) && ARG_TYPE == ARG_STDARG
! 817: /*
! 818: * Stdarg front-end to _fatalerr()
! 819: */
! 820: extern void fatalerr(char *fmt, ...)
! 821: {
! 822: static char buf[MSGBUFSIZ];
! 823: va_list args;
! 824:
! 825: va_start(args, fmt);
! 826: (void) vsprintf(buf, fmt, args);
! 827: va_end(args);
! 828:
! 829: _fatalerr(buf);
! 830: }
! 831: #endif /* ARG_STDARG */
! 832:
! 833: #if !defined(ARG_TYPE)
! 834: /*
! 835: * Simple front-end to _fatalerr()
! 836: */
! 837: /*VARARGS1*/
! 838: extern void fatalerr(fmt, a1, a2, a3, a4, a5)
! 839: char *fmt;
! 840: {
! 841: static char buf[MSGBUFSIZ];
! 842:
! 843: (void) sprintf(buf, fmt, a1, a2, a3, a4, a5);
! 844:
! 845: _fatalerr(buf);
! 846: }
! 847: #endif /* !ARG_TYPE */
! 848:
! 849: /*
! 850: * Get the name of the file used for notify.
! 851: * A side effect is that the file pointer to the file
! 852: * is closed. We assume this function is only called when
! 853: * we are ready to read the file.
! 854: */
! 855: extern char *getnotifyfile()
! 856: {
! 857: register int i;
! 858:
! 859: for (i = 0; msgfacility[i].mf_name; i++)
! 860: if (msgfacility[i].mf_msgfac == MF_NOTIFY &&
! 861: msgfacility[i].mf_fptr) {
! 862: (void) fclose(msgfacility[i].mf_fptr);
! 863: msgfacility[i].mf_fptr = NULL;
! 864: return(msgfacility[i].mf_filename);
! 865: }
! 866:
! 867: return((char *) NULL);
! 868: }
![[BACK]](/icons/back.gif){kind=icon}
Return to message.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / rdist