libatalk/dsi/dsi_stream.c

   1 /*
   2  * $Id: dsi_stream.c,v 1.8 2002-02-02 21:09:13 jmarcus Exp $
   3  *
   4  * Copyright (c) 1998 Adrian Sun (asun@zoology.washington.edu)
   5  * All rights reserved. See COPYRIGHT.
   6  *
   7  * this file provides the following functions:
   8  * dsi_stream_write:    just write a bunch of bytes.
   9  * dsi_stream_read:     just read a bunch of bytes.
  10  * dsi_stream_send:     send a DSI header + data.
  11  * dsi_stream_receive:  read a DSI header + data.
  12  */
  13
  14 #ifdef HAVE_CONFIG_H
  15 #include "config.h"
  16 #endif /* HAVE_CONFIG_H */
  17
  18 #define USE_WRITEV
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #ifdef HAVE_UNISTD_H
  23 #include <unistd.h>
  24 #endif /* HAVE_UNISTD_H */
  25 #include <string.h>
  26 #include <errno.h>
  27 #include <sys/types.h>
  28 #ifdef USE_WRITEV
  29 #include <sys/uio.h>
  30 #endif /* USE_WRITEV */
  31 #include <atalk/logger.h>
  32
  33 #include <atalk/dsi.h>
  34 #include <netatalk/endian.h>
  35
  36 #define min(a,b)  ((a) < (b) ? (a) : (b))
  37
  38
  39 /* write raw data. return actual bytes read. checks against EINTR
  40  * aren't necessary if all of the signals have SA_RESTART
  41  * specified. */
  42 size_t dsi_stream_write(DSI *dsi, void *data, const size_t length)
  43 {
  44   size_t written;
  45   ssize_t len;
  46
  47   written = 0;
  48   while (written < length) {
  49     if (((len = write(dsi->socket, (u_int8_t *) data + written,
  50                       length - written)) == -1 && errno == EINTR) ||
  51         !len)
  52       continue;
  53
  54     if (len < 0) {
  55       LOG(log_error, logtype_default, "dsi_stream_write: %s", strerror(errno));
  56       break;
  57     }
  58
  59     written += len;
  60   }
  61
  62   dsi->write_count += written;
  63   return written;
  64 }
  65
  66 /* read raw data. return actual bytes read. this will wait until
  67  * it gets length bytes */
  68 size_t dsi_stream_read(DSI *dsi, void *data, const size_t length)
  69 {
  70   size_t stored;
  71   ssize_t len;
  72
  73   stored = 0;
  74   while (stored < length) {
  75     len = read(dsi->socket, (u_int8_t *) data + stored, length - stored);
  76     if (len == -1 && errno == EINTR)
  77       continue;
  78     else if (len > 0)
  79       stored += len;
  80     else { /* eof or error */
  81       LOG(log_error, logtype_default, "dsi_stream_read(%d): %s", len, (len < 0)?strerror(errno):"unexpected EOF");
  82       break;
  83     }
  84   }
  85
  86   dsi->read_count += stored;
  87   return stored;
  88 }
  89
  90
  91 /* write data. 0 on failure. this assumes that dsi_len will never
  92  * cause an overflow in the data buffer. */
  93 int dsi_stream_send(DSI *dsi, void *buf, size_t length)
  94 {
  95   char block[DSI_BLOCKSIZ];
  96   sigset_t oldset;
  97 #ifdef USE_WRITEV
  98   struct iovec iov[2];
  99   size_t  towrite;
 100   ssize_t len;
 101 #endif /* USE_WRITEV */
 102
 103   block[0] = dsi->header.dsi_flags;
 104   block[1] = dsi->header.dsi_command;
 105   memcpy(block + 2, &dsi->header.dsi_requestID,
 106          sizeof(dsi->header.dsi_requestID));
 107   memcpy(block + 4, &dsi->header.dsi_code, sizeof(dsi->header.dsi_code));
 108   memcpy(block + 8, &dsi->header.dsi_len, sizeof(dsi->header.dsi_len));
 109   memcpy(block + 12, &dsi->header.dsi_reserved,
 110          sizeof(dsi->header.dsi_reserved));
 111
 112   /* block signals */
 113   sigprocmask(SIG_BLOCK, &dsi->sigblockset, &oldset);
 114
 115   if (!length) { /* just write the header */
 116     length = (dsi_stream_write(dsi, block, sizeof(block)) == sizeof(block));
 117     sigprocmask(SIG_SETMASK, &oldset, NULL);
 118     return length; /* really 0 on failure, 1 on success */
 119   }
 120
 121 #ifdef USE_WRITEV
 122   iov[0].iov_base = block;
 123   iov[0].iov_len = sizeof(block);
 124   iov[1].iov_base = buf;
 125   iov[1].iov_len = length;
 126
 127   towrite = sizeof(block) + length;
 128   dsi->write_count += towrite;
 129   while (towrite > 0) {
 130     if (((len = writev(dsi->socket, iov, 2)) == -1 && errno == EINTR) ||
 131         !len)
 132       continue;
 133
 134     if (len == towrite) /* wrote everything out */
 135       break;
 136     else if (len < 0) { /* error */
 137       LOG(log_error, logtype_default, "dsi_stream_send: %s", strerror(errno));
 138       sigprocmask(SIG_SETMASK, &oldset, NULL);
 139       return 0;
 140     }
 141
 142     towrite -= len;
 143     if (towrite > length) { /* skip part of header */
 144       iov[0].iov_base = (char *) iov[0].iov_base + len;
 145       iov[0].iov_len -= len;
 146     } else { /* skip to data */
 147       if (iov[0].iov_len) {
 148         len -= iov[0].iov_len;
 149         iov[0].iov_len = 0;
 150       }
 151       iov[1].iov_base = (char *) iov[1].iov_base + len;
 152       iov[1].iov_len -= len;
 153     }
 154   }
 155
 156 #else /* USE_WRITEV */
 157   /* write the header then data */
 158   if ((dsi_stream_write(dsi, block, sizeof(block)) != sizeof(block)) ||
 159       (dsi_stream_write(dsi, buf, length) != length)) {
 160     sigprocmask(SIG_SETMASK, &oldset, NULL);
 161     return 0;
 162   }
 163 #endif /* USE_WRITEV */
 164
 165   sigprocmask(SIG_SETMASK, &oldset, NULL);
 166   return 1;
 167 }
 168
 169
 170 /* read data. function on success. 0 on failure. data length gets
 171  * stored in length variable. this should really use size_t's, but
 172  * that would require changes elsewhere. */
 173 int dsi_stream_receive(DSI *dsi, void *buf, const int ilength,
 174                        int *rlength)
 175 {
 176   char block[DSI_BLOCKSIZ];
 177
 178   /* read in the header */
 179   if (dsi_stream_read(dsi, block, sizeof(block)) != sizeof(block))
 180     return 0;
 181
 182   dsi->header.dsi_flags = block[0];
 183   dsi->header.dsi_command = block[1];
 184   /* FIXME, not the right place,
 185      but we get a server disconnect without reason in the log
 186   */
 187   if (!block[1]) {
 188       LOG(log_error, logtype_default, "dsi_stream_receive: invalid packet, fatal");
 189       return 0;
 190   }
 191
 192   memcpy(&dsi->header.dsi_requestID, block + 2,
 193          sizeof(dsi->header.dsi_requestID));
 194   memcpy(&dsi->header.dsi_code, block + 4, sizeof(dsi->header.dsi_code));
 195   memcpy(&dsi->header.dsi_len, block + 8, sizeof(dsi->header.dsi_len));
 196   memcpy(&dsi->header.dsi_reserved, block + 12,
 197          sizeof(dsi->header.dsi_reserved));
 198   dsi->clientID = ntohs(dsi->header.dsi_requestID);
 199
 200   /* make sure we don't over-write our buffers. */
 201   *rlength = min(ntohl(dsi->header.dsi_len), ilength);
 202   if (dsi_stream_read(dsi, buf, *rlength) != *rlength)
 203     return 0;
 204
 205   return block[1];
 206 }