← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/nas/jaunty

« back to all changes in this revision

Viewing changes to lib/audio/Alibint.c

  • Committer: Bazaar Package Importer
  • Author(s): Steve McIntyre
  • Date: 2004-06-23 01:15:02 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20040623011502-30uqd1dyu47iv2dp
Tags: 1.6d-1
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/audio/Alibint.c
19
19
 * WHETHER IN AN ACTION IN CONTRACT, TORT OR NEGLIGENCE, ARISING OUT OF OR IN
20
20
 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
21
21
 * 
22
 
 * $Id: Alibint.c,v 1.5 2000/12/13 04:22:37 jon Exp $
 
22
 * $Id: Alibint.c,v 1.9 2003/12/23 01:01:36 jon Exp $
23
23
 * $NCDId: @(#)Alibint.c,v 1.28 1995/12/28 19:42:47 greg Exp $
24
24
 */
25
25
 
49
49
 
50
50
#include "release.h"
51
51
 
 
52
#if defined(__CYGWIN__)
 
53
#include <asm/socket.h>
 
54
#include <arpa/inet.h>
 
55
#endif
 
56
 
52
57
#include <audio/Alibint.h>
53
58
#include <audio/Aos.h>
54
59
#include "Alibnet.h"
112
117
} _AuAlignedBuffer;
113
118
 
114
119
static char *_AuAsyncReply (
115
 
#if NeedFunctionPrototypes
116
 
    AuServer *,         /* server */
117
 
    auReply *,          /* rep */
118
 
    char *,             /* buf */
119
 
    int *,              /* lenp */
120
 
    AuBool              /* discard */
121
 
#endif
 
120
                            AuServer *,         /* server */
 
121
                            auReply *,          /* rep */
 
122
                            char *,             /* buf */
 
123
                            int *,              /* lenp */
 
124
                            AuBool              /* discard */
122
125
);
123
126
 
124
 
static void _AuEnq(
125
 
#if NeedFunctionPrototypes
126
 
    AuServer *,                 /* server */
127
 
    auEvent *,                  /* event */
128
 
    int                         /* who */
129
 
#endif
 
127
static void _AuEnq(AuServer *,  /* server */
 
128
                   auEvent *,   /* event */
 
129
                   int          /* who */
 
130
 
130
131
);
131
132
 
132
133
static void _AuEventEnqueued(
133
 
#if NeedFunctionPrototypes
134
 
    AuServer *,                 /* server */
135
 
    int,                        /* who */
136
 
    AuEvent *                   /* event */
137
 
#endif
 
134
                             AuServer *,                        /* server */
 
135
                             int,                       /* who */
 
136
                             AuEvent *                  /* event */
138
137
);
139
138
 
140
139
/*
155
154
 * the object they have created.
156
155
 */
157
156
 
 
157
 
 
158
/* this is a mutex for _AuReadEvents() */
 
159
static _AuMutex _rev_mutex = _AU_MUTEX_INITIALIZER;
 
160
 
158
161
static int padlength[4] = {0, 3, 2, 1};
159
162
    /* lookup table for adding padding bytes to data that is read from
160
163
        or written to the Au socket.  */
170
173
 * until the connection is writable.
171
174
 */
172
175
static void
173
 
_AuWaitForWritable(aud)
174
 
    AuServer *aud;
 
176
_AuWaitForWritable(AuServer *aud)
175
177
{
176
178
#if !defined(AMOEBA) && !defined(_MINIX)
177
179
#ifndef WIN32
272
274
 
273
275
 
274
276
static void
275
 
_AuWaitForReadable(aud)
276
 
  AuServer *aud;
 
277
_AuWaitForReadable(AuServer *aud)
277
278
{
278
279
#ifndef WIN32
279
280
#if !defined(AMOEBA) && !defined(_MINIX)
316
317
 * This routine may have to be reworked if int < AuInt32.
317
318
 */
318
319
void
319
 
_AuFlush (aud)
320
 
        register AuServer *aud;
 
320
_AuFlush (register AuServer *aud)
321
321
{
322
322
        register AuInt32 size, todo;
323
323
        register int write_stat;
362
362
}
363
363
 
364
364
int
365
 
_AuEventsQueued (aud, mode)
366
 
    register AuServer *aud;
367
 
    int mode;
 
365
_AuEventsQueued (register AuServer *aud, int mode)
368
366
{
369
367
        register int len;
370
368
        int pend;
449
447
 * then read as many events as possible (but at least 1) and enqueue them
450
448
 */
451
449
void
452
 
_AuReadEvents(aud)
453
 
        register AuServer *aud;
 
450
_AuReadEvents(register AuServer *aud)
454
451
{
455
 
        _AuAlignedBuffer buf;
456
 
        int pend;
457
 
        register int len;
458
 
        register auReply *rep;
459
 
        AuBool not_yet_flushed = AuTrue;
460
 
 
461
 
        do {
462
 
            /* find out how much data can be read */
463
 
            if (BytesReadable(aud->fd, (char *) &pend) < 0)
464
 
                _AuIOError(aud);
465
 
            len = pend;
466
 
 
467
 
            /* must read at least one auEvent; if none is pending, then
468
 
               we'll just flush and block waiting for it */
469
 
            if (len < SIZEOF(auEvent)) {
470
 
                len = SIZEOF(auEvent);
471
 
                /* don't flush until we block the first time */
472
 
                if (not_yet_flushed) {
473
 
                    int qlen = aud->qlen;
474
 
                    _AuFlush (aud);
475
 
                    if (qlen != aud->qlen) return;
476
 
                    not_yet_flushed = AuFalse;
477
 
                }
478
 
            }
479
 
                
480
 
            /* but we won't read more than the max buffer size */
481
 
            if (len > BUFSIZE)
482
 
                len = BUFSIZE;
483
 
 
484
 
            /* round down to an integral number of AuReps */
485
 
            len = (len / SIZEOF(auEvent)) * SIZEOF(auEvent);
486
 
 
487
 
            _AuRead (aud, buf.buf, (AuInt32) len);
488
 
 
489
 
            STARTITERATE(rep,auReply,buf.buf,len > 0) {
490
 
                if (rep->generic.type == Au_Reply) {
491
 
                    pend = len;
492
 
                    RESETITERPTR(rep,auReply,
493
 
                                 _AuAsyncReply (aud, rep,
494
 
                                               ITERPTR(rep), &pend, AuTrue));
495
 
                    len = pend;
496
 
                } else {
497
 
                    if (rep->generic.type == Au_Error)
498
 
                        _AuError (aud, (auError *) rep);
499
 
                    else   /* must be an event packet */
500
 
                        _AuEnq (aud, (auEvent *)rep, AuEventEnqueuedByUnknown);
501
 
                    INCITERPTR(rep,auReply);
502
 
                    len -= SIZEOF(auReply);
503
 
                }
504
 
            } ENDITERATE
505
 
        } while (aud->head == NULL);
 
452
  _AuAlignedBuffer buf;
 
453
  int pend;
 
454
  register int len;
 
455
  register auReply *rep;
 
456
  AuBool not_yet_flushed = AuTrue;
 
457
  
 
458
  /* lock read access to the server */
 
459
  _AuLockMutex(_rev_mutex);
 
460
 
 
461
  do {
 
462
    /* find out how much data can be read */
 
463
    if (BytesReadable(aud->fd, (char *) &pend) < 0)
 
464
      _AuIOError(aud);
 
465
    len = pend;
 
466
    
 
467
    /* must read at least one auEvent; if none is pending, then
 
468
       we'll just flush and block waiting for it */
 
469
    if (len < SIZEOF(auEvent)) {
 
470
      len = SIZEOF(auEvent);
 
471
      /* don't flush until we block the first time */
 
472
      if (not_yet_flushed) {
 
473
        int qlen = aud->qlen;
 
474
        _AuFlush (aud);
 
475
        if (qlen != aud->qlen) return;
 
476
        not_yet_flushed = AuFalse;
 
477
      }
 
478
    }
 
479
    
 
480
    /* but we won't read more than the max buffer size */
 
481
    if (len > BUFSIZE)
 
482
      len = BUFSIZE;
 
483
    
 
484
    /* round down to an integral number of AuReps */
 
485
    len = (len / SIZEOF(auEvent)) * SIZEOF(auEvent);
 
486
    
 
487
    _AuRead (aud, buf.buf, (AuInt32) len);
 
488
    
 
489
    STARTITERATE(rep,auReply,buf.buf,len > 0) {
 
490
      if (rep->generic.type == Au_Reply) {
 
491
        pend = len;
 
492
        RESETITERPTR(rep,auReply,
 
493
                     _AuAsyncReply (aud, rep,
 
494
                                    ITERPTR(rep), &pend, AuTrue));
 
495
        len = pend;
 
496
      } else {
 
497
        if (rep->generic.type == Au_Error)
 
498
          _AuError (aud, (auError *) rep);
 
499
        else   /* must be an event packet */
 
500
          _AuEnq (aud, (auEvent *)rep, AuEventEnqueuedByUnknown);
 
501
        INCITERPTR(rep,auReply);
 
502
        len -= SIZEOF(auReply);
 
503
      }
 
504
    } ENDITERATE
 
505
  } while (aud->head == NULL);
 
506
 
 
507
  _AuUnlockMutex(_rev_mutex);
 
508
 
506
509
}
507
510
 
508
511
/* 
510
513
 * reads.  This routine may have to be reworked if int < AuInt32.
511
514
 */
512
515
void
513
 
_AuRead (aud, data, size)
514
 
        register AuServer *aud;
515
 
        register char *data;
516
 
        register AuInt32 size;
 
516
_AuRead (register AuServer *aud, register char *data, register AuInt32 size)
517
517
{
518
518
        register AuInt32 bytes_read;
519
519
 
567
567
 *            into a AuInt32 (64 bits on a CRAY computer).
568
568
 * 
569
569
 */
570
 
static _doXRead32 (aud, data, size, packbuffer)
571
 
        register AuServer *aud;
572
 
        register AuInt32 *data;
573
 
        register AuInt32 size;
574
 
        register char *packbuffer;
 
570
static _doXRead32 (register AuServer *aud, register AuInt32 *data, 
 
571
                   register AuInt32 size, register char *packbuffer)
575
572
{
576
573
 AuInt32 *lpack,*lp;
577
574
 AuInt32 mask32 = 0x00000000ffffffff;
594
591
        }
595
592
}
596
593
 
597
 
_AuRead32 (aud, data, len)
598
 
    AuServer *aud;
599
 
    AuInt32 *data;
600
 
    AuInt32 len;
 
594
_AuRead32 (AuServer *aud, AuInt32 *data, AuInt32 len)
601
595
{
602
596
    char packbuffer[PACKBUFFERSIZE];
603
597
    unsigned nunits = PACKBUFFERSIZE >> 2;
615
609
 *            into a AuInt32 (64 bits on a CRAY computer).
616
610
 *
617
611
 */
618
 
static _doXRead16 (aud, data, size, packbuffer)
 
612
static _doXRead16 (register AuServer *aud, register short *data, 
 
613
                   register AuInt32 size, char *packbuffer)
619
614
        register AuServer *aud;
620
615
        register short *data;
621
616
        register AuInt32 size;
642
637
        }
643
638
}
644
639
 
645
 
_AuRead16 (aud, data, len)
646
 
    AuServer *aud;
647
 
    short *data;
648
 
    AuInt32 len;
 
640
_AuRead16 (AuServer *aud, short *data, AuInt32 len)
649
641
{
650
642
    char packbuffer[PACKBUFFERSIZE];
651
643
    unsigned nunits = PACKBUFFERSIZE >> 1;
656
648
    if (len) _doXRead16 (aud, data, len, packbuffer);
657
649
}
658
650
 
659
 
_AuRead16Pad (aud, data, size)
660
 
    AuServer *aud;
661
 
    short *data;
662
 
    AuInt32 size;
 
651
_AuRead16Pad (AuServer *aud, short *data, AuInt32 size)
663
652
{
664
653
    int slop = (size & 3);
665
654
    short slopbuf[3];
678
667
 * bytes. This routine may have to be reworked if int < AuInt32.
679
668
 */
680
669
void
681
 
_AuReadPad (aud, data, size)
682
 
        register AuServer *aud; 
683
 
        register char *data;
684
 
        register AuInt32 size;
 
670
_AuReadPad (register AuServer *aud, register char *data, register AuInt32 size)
685
671
{
686
672
        register AuInt32 bytes_read;
687
673
        struct iovec iov[2];
760
746
 * This routine may have to be reworked if int < AuInt32;
761
747
 */
762
748
void
763
 
_AuSend (aud, data, size)
764
 
        register AuServer *aud;
765
 
        char *data;
766
 
        register AuInt32 size;
 
749
_AuSend (register AuServer *aud, char *data, register AuInt32 size)
767
750
{
768
751
        struct iovec iov[3];
769
752
        static char pad[3] = {0, 0, 0};
856
839
 * can roll his own and instatantiate it if he wants, but must
857
840
 * follow the rules.
858
841
 */
859
 
AuID _AuAllocID (aud)
860
 
    register AuServer *aud;
 
842
AuID _AuAllocID (register AuServer *aud)
861
843
{
862
844
   AuID id;
863
845
 
885
867
 */
886
868
 
887
869
AuUint32
888
 
_AuSetLastRequestRead(aud, rep)
889
 
    register AuServer *aud;
890
 
    register auGenericReply *rep;
 
870
_AuSetLastRequestRead(register AuServer *aud, register auGenericReply *rep)
891
871
{
892
872
    register AuUint32   newseq, lastseq;
893
873
 
914
894
 * _AuReply - Wait for a reply packet and copy its contents into the
915
895
 * specified rep.  Mean while we must handle error and event packets that
916
896
 * we may encounter.
 
897
 *
 
898
 *   int extra;         number of 32-bit words expected after the reply 
 
899
 *   AuBool discard;    should I discard data following "extra" words? 
917
900
 */
918
 
AuBool _AuReply (aud, rep, extra, discard, ret_status)
919
 
    register AuServer *aud;
920
 
    register auReply *rep;
921
 
    int extra;          /* number of 32-bit words expected after the reply */
922
 
    AuBool discard;     /* should I discard data following "extra" words? */
923
 
    AuStatus *ret_status;
 
901
AuBool _AuReply (register AuServer *aud, register auReply *rep, 
 
902
                 int extra, AuBool discard, AuStatus *ret_status)
924
903
{
925
904
    /* Pull out the serial number now, so that (currently illegal) requests
926
905
     * generated by an error handler don't confuse us.
1041
1020
}   
1042
1021
 
1043
1022
static char *
1044
 
_AuAsyncReply(aud, rep, buf, lenp, discard)
1045
 
    AuServer *aud;
1046
 
    register auReply *rep;
1047
 
    char *buf;
1048
 
    register int *lenp;
1049
 
    AuBool discard;
 
1023
_AuAsyncReply(AuServer *aud, register auReply *rep, char *buf, 
 
1024
              register int *lenp, AuBool discard)
1050
1025
{
1051
1026
    register _AuAsyncHandler *async, *next;
1052
1027
    register int len;
1102
1077
 * error_code, major, and minor all to 0 to catch all errors.
1103
1078
 */
1104
1079
AuBool
1105
 
_AuForceRoundTrip (aud, error_code, majorop, minorop, ret_status)
1106
 
    AuServer *aud;
1107
 
    int error_code;
1108
 
    int majorop;
1109
 
    int minorop;
1110
 
    AuStatus *ret_status;
 
1080
_AuForceRoundTrip (AuServer *aud, int error_code, int majorop, int minorop, 
 
1081
                   AuStatus *ret_status)
1111
1082
{
1112
1083
    AuUint32 seq = aud->request;         /* get previous request */
1113
1084
    auGetCloseDownModeReply rep;
1143
1114
 
1144
1115
/* Read and discard "n" 8-bit bytes of data */
1145
1116
 
1146
 
void _AuEatData (aud, n)
1147
 
    AuServer *aud;
1148
 
    register AuUint32 n;
 
1117
void _AuEatData (AuServer *aud, register AuUint32 n)
1149
1118
{
1150
1119
#define SCRATCHSIZE 2048
1151
1120
    char buf[SCRATCHSIZE];
1159
1128
}
1160
1129
 
1161
1130
AuEventEnqHandlerRec *
1162
 
AuRegisterEventEnqHandler(aud, who, callback, data)
1163
 
AuServer       *aud;
1164
 
int             who;
1165
 
AuEventEnqHandlerCallback callback;
1166
 
AuPointer       data;
 
1131
AuRegisterEventEnqHandler(AuServer *aud, int who, 
 
1132
                          AuEventEnqHandlerCallback callback, 
 
1133
                          AuPointer data)
1167
1134
{
1168
1135
    AuEventEnqHandlerRec *handler;
1169
1136
 
1181
1148
}
1182
1149
 
1183
1150
void
1184
 
AuUnregisterEventEnqHandler(aud, handler)
1185
 
AuServer       *aud;
1186
 
AuEventEnqHandlerRec *handler;
 
1151
AuUnregisterEventEnqHandler(AuServer *aud, AuEventEnqHandlerRec *handler)
1187
1152
{
1188
1153
    _AuRemoveFromLinkedList(aud->eventenqhandlerq, handler);
1189
1154
    Aufree(handler);
1190
1155
}
1191
1156
 
1192
1157
static void
1193
 
_AuEventEnqueued(aud, who, event)
1194
 
AuServer       *aud;
1195
 
int             who;
1196
 
AuEvent        *event;
 
1158
_AuEventEnqueued(AuServer *aud, int who, AuEvent *event)
1197
1159
{
1198
1160
    AuEventEnqHandlerRec *p = aud->eventenqhandlerq,
1199
1161
                   *next;
1211
1173
 * _AuEnq - Place event packets on the server's queue.
1212
1174
 */
1213
1175
static void
1214
 
_AuEnq (aud, event, who)
1215
 
        register AuServer *aud;
1216
 
        register auEvent *event;
1217
 
        int who;
 
1176
_AuEnq (register AuServer *aud, register auEvent *event, int who)
1218
1177
{
1219
1178
        register _AuQEvent *qelt;
1220
1179
 
1246
1205
}
1247
1206
/*
1248
1207
 * EventToWire in separate file in that often not needed.
 
1208
 *
 
1209
 * AuServer *aud;        pointer to server structure 
 
1210
 * AuEvent *re;          pointer to where event should be reformatted 
 
1211
 * auEvent *event;       wire protocol event 
1249
1212
 */
1250
1213
 
1251
1214
/*ARGSUSED*/
1252
1215
AuBool
1253
 
_AuUnknownWireEvent(aud, re, event)
1254
 
register AuServer *aud; /* pointer to server structure */
1255
 
register AuEvent *re;   /* pointer to where event should be reformatted */
1256
 
register auEvent *event;        /* wire protocol event */
 
1216
_AuUnknownWireEvent(register AuServer *aud, register AuEvent *re, 
 
1217
                    register auEvent *event)
1257
1218
{
1258
1219
#ifdef notdef
1259
1220
        (void) fprintf(stderr, 
1265
1226
 
1266
1227
/*ARGSUSED*/
1267
1228
AuStatus
1268
 
_AuUnknownNativeEvent(aud, re, event)
1269
 
register AuServer *aud; /* pointer to server structure */
1270
 
register AuEvent *re;   /* pointer to where event should be reformatted */
1271
 
register auEvent *event;        /* wire protocol event */
 
1229
_AuUnknownNativeEvent(register AuServer *aud, register AuEvent *re, 
 
1230
                      register auEvent *event)
1272
1231
{
1273
1232
#ifdef notdef
1274
1233
        (void) fprintf(stderr, 
1281
1240
 * reformat a wire event into an AuEvent structure of the right type.
1282
1241
 */
1283
1242
AuBool
1284
 
_AuWireToEvent(aud, re, event)
1285
 
register AuServer *aud;                         /* pointer to server
1286
 
                                                 * structure */
1287
 
register AuEvent *re;                           /* pointer to where event
1288
 
                                                 * should be reformatted */
1289
 
register auEvent *event;                        /* wire protocol event */
 
1243
_AuWireToEvent(register AuServer *aud, register AuEvent *re, 
 
1244
               register auEvent *event)
1290
1245
{
1291
1246
 
1292
1247
    re->type = event->u.u.type & 0x7f;
1344
1299
 
1345
1300
#ifndef USL_SHARELIB
1346
1301
 
1347
 
static char *_SysErrorMsg (n)
1348
 
    int n;
 
1302
static char *_SysErrorMsg (int n)
1349
1303
{
1350
 
#if !defined(__FreeBSD__) && !defined(__linux__) && !defined(__NetBSD__)
1351
 
    extern char *sys_errlist[];
1352
 
#endif
1353
 
    extern int sys_nerr;
1354
 
    char *s = (char *)((n >= 0 && n < sys_nerr) ? sys_errlist[n] : "unknown error");
1355
 
 
1356
 
    return (s ? s : "no such error");
 
1304
  return (strerror(n));
1357
1305
}
1358
1306
 
1359
1307
#endif  /* USL sharedlibs in don't define for AUD3.2 */
1364
1312
 * when an Au internal system error is encountered.
1365
1313
 */
1366
1314
void
1367
 
_AuDefaultIOError (aud)
1368
 
        AuServer *aud;
 
1315
_AuDefaultIOError (AuServer *aud)
1369
1316
{
1370
1317
        if (errno == EPIPE) {
1371
1318
            (void) fprintf (stderr,
1381
1328
                        AuServerQLength(aud));
1382
1329
 
1383
1330
        }
1384
 
        exit(1);
 
1331
        exit(1);                /* JET - is there a way to handle this
 
1332
                                   w/o being so heavy-handed? */
1385
1333
}
1386
1334
 
1387
1335
 
1388
 
int _AuPrintDefaultError (aud, event, fp)
1389
 
    AuServer *aud;
1390
 
    AuErrorEvent *event;
1391
 
    FILE *fp;
 
1336
int _AuPrintDefaultError (AuServer *aud, AuErrorEvent *event, FILE *fp)
1392
1337
{
1393
1338
    char buffer[BUFSIZ];
1394
1339
    char mesg[BUFSIZ];
1475
1420
    return 1;
1476
1421
}
1477
1422
 
1478
 
int _AuDefaultError(aud, event)
1479
 
        AuServer *aud;
1480
 
        AuErrorEvent *event;
 
1423
int _AuDefaultError(AuServer *aud, AuErrorEvent *event)
1481
1424
{
1482
1425
    if (_AuPrintDefaultError (aud, event, stderr) == 0) return 0;
1483
1426
    exit(1);
1485
1428
}
1486
1429
 
1487
1430
/*ARGSUSED*/
1488
 
AuBool _AuDefaultWireError(server, he, we)
1489
 
    AuServer     *server;
1490
 
    AuErrorEvent *he;
1491
 
    auError      *we;
 
1431
AuBool _AuDefaultWireError(AuServer *server, AuErrorEvent *he, 
 
1432
                           auError *we)
1492
1433
{
1493
1434
    return AuTrue;
1494
1435
}
1496
1437
/*
1497
1438
 * _AuError - upcall internal or user protocol error handler
1498
1439
 */
1499
 
int _AuError (aud, rep)
1500
 
    AuServer *aud;
1501
 
    register auError *rep;
 
1440
int _AuError (AuServer *aud, register auError *rep)
1502
1441
{
1503
1442
    /* 
1504
1443
     * Au_Error packet encountered!  We need to unpack the error before
1544
1483
/*
1545
1484
 * _AuIOError - call user connection error handler and exit
1546
1485
 */
1547
 
int _AuIOError (aud)
1548
 
    AuServer *aud;
 
1486
int _AuIOError (AuServer *aud)
1549
1487
{
1550
1488
    aud->flags |= AuServerFlagsIOError;
1551
1489
    if (aud->funcs.ioerror_handler != NULL)
1561
1499
 * audiolib routine for scratch space.  It is reallocated from the same place
1562
1500
 * each time, unless the library needs a large scratch space.
1563
1501
 */
1564
 
char *_AuAllocScratch (aud, nbytes)
1565
 
        register AuServer *aud;
1566
 
        AuUint32 nbytes;
 
1502
char *_AuAllocScratch (register AuServer *aud, AuUint32 nbytes)
1567
1503
{
1568
1504
        if (nbytes > aud->scratch_length) {
1569
 
            if (aud->scratch_buffer) Aufree (aud->scratch_buffer);
1570
 
            if ((aud->scratch_buffer = Aumalloc((unsigned) nbytes)) != NULL)
1571
 
                aud->scratch_length = nbytes;
 
1505
            if (aud->scratch_buffer) Aufree ((void *)aud->scratch_buffer);
 
1506
            if ((aud->scratch_buffer = 
 
1507
                 (char *)Aumalloc((unsigned) nbytes)) != NULL)
 
1508
              aud->scratch_length = nbytes;
1572
1509
            else aud->scratch_length = 0;
1573
1510
        }
1574
 
        return (aud->scratch_buffer);
 
1511
        return ((char *)aud->scratch_buffer);
1575
1512
}
1576
1513
 
1577
1514
 
1578
1515
void 
1579
 
AuFree (data)
1580
 
    AuPointer data;
 
1516
AuFree (AuPointer data)
1581
1517
{
1582
1518
        Aufree (data);
1583
1519
}
1584
1520
 
1585
1521
#ifdef _AUNEEDBCOPYFUNC
1586
 
void _Aubcopy(b1, b2, length)
1587
 
    register char *b1, *b2;
1588
 
    register length;
 
1522
void _Aubcopy(register char *b1, register char *b2, register int length)
1589
1523
{
1590
1524
    if (b1 < b2) {
1591
1525
        b2 += length;
1600
1534
#endif
1601
1535
 
1602
1536
#ifdef _AuDataRoutineIsProcedure
1603
 
void _AuData (aud, data, len)
1604
 
        AuServer *aud;
1605
 
        char *data;
1606
 
        AuInt32 len;
 
1537
void _AuData (AuServer *aud, char *data, AuInt32 len)
1607
1538
{
1608
1539
        if (aud->bufptr + (len) <= aud->bufmax) {
1609
1540
                bcopy(data, aud->bufptr, (int)len);
1630
1561
 * "len" is the length in bytes of the data.
1631
1562
 */
1632
1563
 
1633
 
static do_AuData16(aud, data, len, packbuffer)
1634
 
    register AuServer *aud;
1635
 
    short *data;
1636
 
    unsigned len;
1637
 
    char *packbuffer;
 
1564
static do_AuData16(register AuServer *aud, short *data, unsigned int len, 
 
1565
                   char *packbuffer)
1638
1566
{
1639
1567
    AuInt32 *lp,*lpack;
1640
1568
    AuInt32 i, nwords,bits;
1663
1591
        _AuData(aud, packbuffer, len);
1664
1592
}
1665
1593
 
1666
 
_AuData16 (aud, data, len)
1667
 
    AuServer *aud;
1668
 
    short *data;
1669
 
    unsigned len;
 
1594
_AuData16 (AuServer *aud, short *data, unsigned int len)
1670
1595
{
1671
1596
    char packbuffer[PACKBUFFERSIZE];
1672
1597
    unsigned nunits = PACKBUFFERSIZE >> 1;
1685
1610
 * "len" is the length in bytes of the data.
1686
1611
 */
1687
1612
 
1688
 
static do_AuData32 (aud, data, len, packbuffer)
1689
 
    register AuServer *aud;
1690
 
    AuInt32 *data;
1691
 
    unsigned len;
1692
 
    char *packbuffer;
 
1613
static do_AuData32 (register AuServer *aud, AuInt32 *data, 
 
1614
                    unsigned int len, char *packbuffer)
1693
1615
{
1694
1616
    AuInt32 *lp,*lpack;
1695
1617
    AuInt32 i,bits,nwords;
1716
1638
        _AuData(aud, packbuffer, len);
1717
1639
}
1718
1640
 
1719
 
_AuData32 (aud, data, len)
1720
 
    AuServer *aud;
1721
 
    AuInt32 *data;
1722
 
    unsigned len;
 
1641
_AuData32 (AuServer *aud, AuInt32 *data, unsigned int len)
1723
1642
{
1724
1643
    char packbuffer[PACKBUFFERSIZE];
1725
1644
    unsigned nunits = PACKBUFFERSIZE >> 2;
1738
1657
 * aud->qfree - free the queue of events, called by AuCloseServer
1739
1658
 */
1740
1659
 
1741
 
void _AuFreeQ (aud)
1742
 
    AuServer *aud;
 
1660
void _AuFreeQ (AuServer *aud)
1743
1661
{
1744
1662
    register _AuQEvent *qelt = aud->qfree;
1745
1663
  
1769
1687
/*
1770
1688
 * _AuGetHostname - similar to gethostname but allows special processing.
1771
1689
 */
1772
 
int _AuGetHostname (buf, maxlen)
1773
 
    char *buf;
1774
 
    int maxlen;
 
1690
int _AuGetHostname (char *buf, int maxlen)
1775
1691
{
1776
1692
    int len;
1777
1693
 
1799
1715
 * This is a macro if MSKCNT <= 4
1800
1716
 */
1801
1717
int
1802
 
_AuANYSET(src)
1803
 
    AuInt32     *src;
 
1718
_AuANYSET(AuInt32 *src)
1804
1719
{
1805
1720
    int i;
1806
1721
 
1819
1734
 */
1820
1735
#include <sys/socket.h>
1821
1736
 
1822
 
int _AuReadV (fd, iov, iovcnt)
1823
 
int fd;
1824
 
struct iovec *iov;
1825
 
int iovcnt;
 
1737
int _AuReadV (int fd, struct iovec *iov, int iovcnt)
1826
1738
{
1827
 
        struct msghdr hdr;
1828
 
 
1829
 
        hdr.msg_iov = iov;
1830
 
        hdr.msg_iovlen = iovcnt;
1831
 
        hdr.msg_accrights = 0;
1832
 
        hdr.msg_accrightslen = 0;
1833
 
        hdr.msg_name = 0;
1834
 
        hdr.msg_namelen = 0;
1835
 
 
1836
 
        return (recvmsg (fd, &hdr, 0));
 
1739
  struct msghdr hdr;
 
1740
  
 
1741
  hdr.msg_iov = iov;
 
1742
  hdr.msg_iovlen = iovcnt;
 
1743
  hdr.msg_accrights = 0;
 
1744
  hdr.msg_accrightslen = 0;
 
1745
  hdr.msg_name = 0;
 
1746
  hdr.msg_namelen = 0;
 
1747
  
 
1748
  return (recvmsg (fd, &hdr, 0));
1837
1749
}
1838
1750
 
1839
 
int _AuWriteV (fd, iov, iovcnt)
1840
 
int fd;
1841
 
struct iovec *iov;
1842
 
int iovcnt;
 
1751
int _AuWriteV (int fd, struct iovec *iov, int iovcnt)
1843
1752
{
1844
 
        struct msghdr hdr;
1845
 
 
1846
 
        hdr.msg_iov = iov;
1847
 
        hdr.msg_iovlen = iovcnt;
1848
 
        hdr.msg_accrights = 0;
1849
 
        hdr.msg_accrightslen = 0;
1850
 
        hdr.msg_name = 0;
1851
 
        hdr.msg_namelen = 0;
1852
 
 
1853
 
        return (sendmsg (fd, &hdr, 0));
 
1753
  struct msghdr hdr;
 
1754
  
 
1755
  hdr.msg_iov = iov;
 
1756
  hdr.msg_iovlen = iovcnt;
 
1757
  hdr.msg_accrights = 0;
 
1758
  hdr.msg_accrightslen = 0;
 
1759
  hdr.msg_name = 0;
 
1760
  hdr.msg_namelen = 0;
 
1761
  
 
1762
  return (sendmsg (fd, &hdr, 0));
1854
1763
}
1855
1764
 
1856
1765
#endif /* CRAY */
1864
1773
#include <sys/uio.h>
1865
1774
#endif /* !WIN32 */
1866
1775
 
1867
 
int _AuReadV (fd, iov, iovcnt)
1868
 
int fd;
1869
 
struct iovec *iov;
1870
 
int iovcnt;
 
1776
int _AuReadV (int fd, struct iovec *iov, int iovcnt)
1871
1777
{
1872
 
    int i, len, total;
1873
 
    char *base;
1874
 
 
1875
 
    errno = 0;
1876
 
    for (i=0, total=0;  i<iovcnt;  i++, iov++) {
1877
 
        len = iov->iov_len;
1878
 
        base = iov->iov_base;
1879
 
        while (len > 0) {
1880
 
            register int nbytes;
 
1778
  int i, len, total;
 
1779
  char *base;
 
1780
  
 
1781
  errno = 0;
 
1782
  for (i=0, total=0;  i<iovcnt;  i++, iov++) {
 
1783
    len = iov->iov_len;
 
1784
    base = iov->iov_base;
 
1785
    while (len > 0) {
 
1786
      register int nbytes;
1881
1787
#ifndef WIN32
1882
 
            nbytes = read(fd, base, len);
 
1788
      nbytes = read(fd, base, len);
1883
1789
#else /* WIN32 */
1884
 
            nbytes = recv(fd, base, len, 0);
 
1790
      nbytes = recv(fd, base, len, 0);
1885
1791
#endif /* WIN32 */
1886
 
            if (nbytes < 0 && total == 0)  return -1;
1887
 
            if (nbytes <= 0)  return total;
1888
 
            errno = 0;
1889
 
            len   -= nbytes;
1890
 
            total += nbytes;
1891
 
            base  += nbytes;
1892
 
        }
 
1792
      if (nbytes < 0 && total == 0)  return -1;
 
1793
      if (nbytes <= 0)  return total;
 
1794
      errno = 0;
 
1795
      len   -= nbytes;
 
1796
      total += nbytes;
 
1797
      base  += nbytes;
1893
1798
    }
1894
 
    return total;
 
1799
  }
 
1800
  return total;
1895
1801
}
1896
1802
 
1897
1803
#ifdef WIN32
1898
 
int _AuWriteV (fd, iov, iovcnt)
1899
 
int fd;
1900
 
struct iovec *iov;
1901
 
int iovcnt;
 
1804
int _AuWriteV (int fd, struct iovec *iov, int iovcnt)
1902
1805
{
1903
 
    int i, len, total;
1904
 
    char *base;
1905
 
 
1906
 
    errno = 0;
1907
 
    for (i=0, total=0;  i<iovcnt;  i++, iov++) {
1908
 
        len = iov->iov_len;
1909
 
        base = iov->iov_base;
1910
 
        while (len > 0) {
1911
 
            register int nbytes;
1912
 
            nbytes = send(fd, base, len, 0);
1913
 
            if (nbytes < 0 && total == 0)  return -1;
1914
 
            if (nbytes <= 0)  return total;
1915
 
            errno = 0;
1916
 
            len   -= nbytes;
1917
 
            total += nbytes;
1918
 
            base  += nbytes;
1919
 
        }
 
1806
  int i, len, total;
 
1807
  char *base;
 
1808
  
 
1809
  errno = 0;
 
1810
  for (i=0, total=0;  i<iovcnt;  i++, iov++) {
 
1811
    len = iov->iov_len;
 
1812
    base = iov->iov_base;
 
1813
    while (len > 0) {
 
1814
      register int nbytes;
 
1815
      nbytes = send(fd, base, len, 0);
 
1816
      if (nbytes < 0 && total == 0)  return -1;
 
1817
      if (nbytes <= 0)  return total;
 
1818
      errno = 0;
 
1819
      len   -= nbytes;
 
1820
      total += nbytes;
 
1821
      base  += nbytes;
1920
1822
    }
1921
 
    return total;
 
1823
  }
 
1824
  return total;
1922
1825
}
1923
1826
#endif /* WIN32 */
1924
1827
 
1974
1877
 
1975
1878
 
1976
1879
int
1977
 
_AuReadV (fd, v, n)
1978
 
    int         fd;
1979
 
    struct iovec v[];
1980
 
    int         n;
 
1880
_AuReadV (int fd, struct iovec v[], int n)
1981
1881
{
1982
 
        int i, rc, len, size = 0;
1983
 
        char * buf = workarea;
1984
 
        char * p;
1985
 
 
1986
 
        if (n <= 0 || n > 16)
1987
 
        {
1988
 
                errno = EINVAL;
1989
 
                return (-1);
1990
 
        }
1991
 
        for (i = 0; i < n; ++i)
1992
 
        {
1993
 
                if ((len = v[i].iov_len) < 0 || v[i].iov_base == NULL)
1994
 
                {
1995
 
                        errno = EINVAL;
1996
 
                        return (-1);
1997
 
                }
1998
 
                size += len;
1999
 
        }
2000
 
        if ((size > MAX_WORKAREA) && ((buf = malloc (size)) == NULL))
2001
 
        {
2002
 
                errno = EINVAL;
2003
 
                return (-1);
2004
 
        }
2005
 
        if((rc = (*_AusStream[_AusTypeOfStream[fd]].ReadFromStream)(fd, buf, size,
2006
 
                                                             BUFFERING))> 0)
2007
 
        {
2008
 
                for (i = 0, p = buf; i < n; ++i)
2009
 
                {
2010
 
                        memcpy (v[i].iov_base, p, len = v[i].iov_len);
2011
 
                        p += len;
2012
 
                }
2013
 
        }
2014
 
        if (size > MAX_WORKAREA)
2015
 
                free (buf);
2016
 
 
2017
 
        return (rc);
 
1882
  int i, rc, len, size = 0;
 
1883
  char * buf = workarea;
 
1884
  char * p;
 
1885
  
 
1886
  if (n <= 0 || n > 16)
 
1887
    {
 
1888
      errno = EINVAL;
 
1889
      return (-1);
 
1890
    }
 
1891
  for (i = 0; i < n; ++i)
 
1892
    {
 
1893
      if ((len = v[i].iov_len) < 0 || v[i].iov_base == NULL)
 
1894
        {
 
1895
          errno = EINVAL;
 
1896
          return (-1);
 
1897
        }
 
1898
      size += len;
 
1899
    }
 
1900
  if ((size > MAX_WORKAREA) && ((buf = malloc (size)) == NULL))
 
1901
    {
 
1902
      errno = EINVAL;
 
1903
      return (-1);
 
1904
    }
 
1905
  if((rc = (*_AusStream[_AusTypeOfStream[fd]].ReadFromStream)(fd, buf, size,
 
1906
                                                              BUFFERING))> 0)
 
1907
    {
 
1908
      for (i = 0, p = buf; i < n; ++i)
 
1909
        {
 
1910
          memcpy (v[i].iov_base, p, len = v[i].iov_len);
 
1911
          p += len;
 
1912
        }
 
1913
    }
 
1914
  if (size > MAX_WORKAREA)
 
1915
    free (buf);
 
1916
  
 
1917
  return (rc);
2018
1918
}
2019
1919
 
2020
1920
int
2021
 
_AuWriteV (fd, v, n)
2022
 
    int fd;
2023
 
    struct iovec v[];
2024
 
    int n;
 
1921
_AuWriteV (int fd, struct iovec v[], int n)
2025
1922
{
2026
 
        int i, rc, len, size = 0;
2027
 
        char * buf = workarea;
2028
 
        char * p;
2029
 
 
2030
 
        if (n <= 0 || n > 16)
2031
 
        {
2032
 
                errno = EINVAL;
2033
 
                return (-1);
2034
 
        }
2035
 
        for (i = 0; i < n; ++i)
2036
 
        {
2037
 
                if ((len = v[i].iov_len) < 0 || v[i].iov_base == NULL)
2038
 
                {
2039
 
                        errno = EINVAL;
2040
 
                        return (-1);
2041
 
                }
2042
 
                size += len;
2043
 
        }
2044
 
 
2045
 
        if ((size > MAX_WORKAREA) && ((buf = malloc (size)) == NULL))
2046
 
        {
2047
 
                errno = EINVAL;
2048
 
                return (-1);
2049
 
        }
2050
 
        for (i = 0, p = buf; i < n; ++i)
2051
 
        {
2052
 
                memcpy (p, v[i].iov_base, len = v[i].iov_len);
2053
 
                p += len;
2054
 
        }
2055
 
        rc = (*_AusStream[_AusTypeOfStream[fd]].WriteToStream)(fd, buf, size);
2056
 
 
2057
 
        if (size > MAX_WORKAREA)
2058
 
                free (buf);
2059
 
 
2060
 
        return (rc);
 
1923
  int i, rc, len, size = 0;
 
1924
  char * buf = workarea;
 
1925
  char * p;
 
1926
  
 
1927
  if (n <= 0 || n > 16)
 
1928
    {
 
1929
      errno = EINVAL;
 
1930
      return (-1);
 
1931
    }
 
1932
  for (i = 0; i < n; ++i)
 
1933
    {
 
1934
      if ((len = v[i].iov_len) < 0 || v[i].iov_base == NULL)
 
1935
        {
 
1936
          errno = EINVAL;
 
1937
          return (-1);
 
1938
        }
 
1939
      size += len;
 
1940
    }
 
1941
  
 
1942
  if ((size > MAX_WORKAREA) && ((buf = malloc (size)) == NULL))
 
1943
    {
 
1944
      errno = EINVAL;
 
1945
      return (-1);
 
1946
    }
 
1947
  for (i = 0, p = buf; i < n; ++i)
 
1948
    {
 
1949
      memcpy (p, v[i].iov_base, len = v[i].iov_len);
 
1950
      p += len;
 
1951
    }
 
1952
  rc = (*_AusStream[_AusTypeOfStream[fd]].WriteToStream)(fd, buf, size);
 
1953
  
 
1954
  if (size > MAX_WORKAREA)
 
1955
    free (buf);
 
1956
  
 
1957
  return (rc);
2061
1958
}
2062
1959
 
2063
1960
 
2066
1963
 
2067
1964
#ifndef HAS_FAKE_IOV
2068
1965
int
2069
 
_AuReadV (fd, v, n)
2070
 
    int         fd;
2071
 
    struct iovec v[];
2072
 
    int         n;
 
1966
_AuReadV (int fd, struct iovec v[], int n)
2073
1967
{
2074
 
        return(readv(fd, v, n));
 
1968
  return(readv(fd, v, n));
2075
1969
}
2076
1970
 
2077
1971
int
2078
 
_AuWriteV (fd, v, n)
2079
 
    int fd;
2080
 
    struct iovec v[];
2081
 
    int n;
 
1972
_AuWriteV (int fd, struct iovec v[], int n)
2082
1973
{
2083
 
        return(writev(fd, v, n));
 
1974
  return(writev(fd, v, n));
2084
1975
}
2085
1976
#endif /* HAS_FAKE_IOV */
2086
1977
 
2087
1978
AuSyncHandlerRec *
2088
 
AuRegisterSyncHandler(aud, callback, data)
2089
 
AuServer       *aud;
2090
 
AuSyncHandlerCallback callback;
2091
 
AuPointer       data;
 
1979
AuRegisterSyncHandler(AuServer *aud, AuSyncHandlerCallback callback, 
 
1980
                      AuPointer data)
2092
1981
{
2093
1982
    AuSyncHandlerRec *handler;
2094
1983
 
2104
1993
}
2105
1994
 
2106
1995
void
2107
 
AuUnregisterSyncHandler(aud, handler)
2108
 
AuServer       *aud;
2109
 
AuSyncHandlerRec *handler;
 
1996
AuUnregisterSyncHandler(AuServer *aud, AuSyncHandlerRec *handler)
2110
1997
{
2111
1998
    _AuRemoveFromLinkedList(aud->synchandler, handler);
2112
1999
    Aufree(handler);
2113
2000
}
2114
2001
 
2115
2002
void
2116
 
_AuDoSyncHandle(aud)
2117
 
AuServer       *aud;
 
2003
_AuDoSyncHandle(AuServer *aud)
2118
2004
{
2119
2005
    AuSyncHandlerRec *p = aud->synchandler,
2120
2006
                   *next;