Return to ryresp-error.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / doc / manual

Annotation of 43BSDReno/contrib/isode-beta/doc/manual/ryresp-error.c, revision 1.1.1.1

1.1       root        1: ...
                      2: 
                      3: void   ros_adios (rop, event)
                      4: register struct RoSAPpreject *rop;
                      5: char   *event;
                      6: {
                      7:     ros_advise (rop, event);
                      8: 
                      9:     longjmp (toplevel, NOTOK);
                     10: }
                     11: 
                     12: 
                     13: void   ros_advise (rop, event)
                     14: register struct RoSAPpreject *rop;
                     15: char   *event;
                     16: {
                     17:     char    buffer[BUFSIZ];
                     18: 
                     19:     if (rop -> rop_cc > 0)
                     20:        (void) sprintf (buffer, "[%s] %*.*s", RoErrString (rop -> rop_reason),
                     21:                rop -> rop_cc, rop -> rop_cc, rop -> rop_data);
                     22:     else
                     23:        (void) sprintf (buffer, "[%s]", RoErrString (rop -> rop_reason));
                     24: 
                     25:     advise (LLOG_EXCEPTIONS, NULLCP, "%s: %s", event, buffer);
                     26: }
                     27: 
                     28: 
                     29: void   acs_advise (aca, event)
                     30: register struct AcSAPabort *aca;
                     31: char   *event;
                     32: {
                     33:     char    buffer[BUFSIZ];
                     34: 
                     35:     if (aca -> aca_cc > 0)
                     36:        (void) sprintf (buffer, "[%s] %*.*s",
                     37:                AcErrString (aca -> aca_reason),
                     38:                aca -> aca_cc, aca -> aca_cc, aca -> aca_data);
                     39:     else
                     40:        (void) sprintf (buffer, "[%s]", AcErrString (aca -> aca_reason));
                     41: 
                     42:     advise (LLOG_EXCEPTIONS, NULLCP, "%s: %s (source %d)", event, buffer,
                     43:                aca -> aca_source);
                     44: }
                     45: 
                     46: 
                     47: #ifndef        lint
                     48: void   adios (va_alist)
                     49: va_dcl
                     50: {
                     51:     va_list ap;
                     52: 
                     53:     va_start (ap);
                     54:     
                     55:     _ll_log (pgm_log, LLOG_FATAL, ap);
                     56: 
                     57:     va_end (ap);
                     58: 
                     59:     _exit (1);
                     60: }
                     61: #else
                     62: /* VARARGS2 */
                     63: 
                     64: void   adios (what, fmt)
                     65: char   *what,
                     66:        *fmt;
                     67: {
                     68:     adios (what, fmt);
                     69: }
                     70: #endif
                     71: 
                     72: 
                     73: #ifndef        lint
                     74: void   advise (va_alist)
                     75: va_dcl
                     76: {
                     77:     int            code;
                     78:     va_list ap;
                     79: 
                     80:     va_start (ap);
                     81: 
                     82:     code = va_arg (ap, int);
                     83: 
                     84:     _ll_log (pgm_log, code, ap);
                     85: 
                     86:     va_end (ap);
                     87: }
                     88: #else
                     89: /* VARARGS3 */
                     90: 
                     91: void   advise (code, what, fmt)
                     92: char   *what,
                     93:        *fmt;
                     94: int    code;
                     95: {
                     96:     advise (code, what, fmt);
                     97: }
                     98: #endif

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.