src/syncio.c

   1 /* Synchronous socket and file I/O operations useful across the core.
   2  *
   3  * Copyright (c) 2009-2010, Salvatore Sanfilippo <antirez at gmail dot com>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are met:
   8  *
   9  *   * Redistributions of source code must retain the above copyright notice,
  10  *     this list of conditions and the following disclaimer.
  11  *   * Redistributions in binary form must reproduce the above copyright
  12  *     notice, this list of conditions and the following disclaimer in the
  13  *     documentation and/or other materials provided with the distribution.
  14  *   * Neither the name of Redis nor the names of its contributors may be used
  15  *     to endorse or promote products derived from this software without
  16  *     specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  19  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  22  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  23  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  24  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  25  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  26  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  27  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28  * POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "redis.h"
  32
  33 /* ----------------- Blocking sockets I/O with timeouts --------------------- */
  34
  35 /* Redis performs most of the I/O in a nonblocking way, with the exception
  36  * of the SYNC command where the slave does it in a blocking way, and
  37  * the MIGRATE command that must be blocking in order to be atomic from the
  38  * point of view of the two instances (one migrating the key and one receiving
  39  * the key). This is why need the following blocking I/O functions. */
  40
  41 int syncWrite(int fd, char *ptr, ssize_t size, int timeout) {
  42     ssize_t nwritten, ret = size;
  43     time_t start = time(NULL);
  44
  45     timeout++;
  46     while(size) {
  47         if (aeWait(fd,AE_WRITABLE,1000) & AE_WRITABLE) {
  48             nwritten = write(fd,ptr,size);
  49             if (nwritten == -1) return -1;
  50             ptr += nwritten;
  51             size -= nwritten;
  52         }
  53         if ((time(NULL)-start) > timeout) {
  54             errno = ETIMEDOUT;
  55             return -1;
  56         }
  57     }
  58     return ret;
  59 }
  60
  61 int syncRead(int fd, char *ptr, ssize_t size, int timeout) {
  62     ssize_t nread, totread = 0;
  63     time_t start = time(NULL);
  64
  65     timeout++;
  66     while(size) {
  67         if (aeWait(fd,AE_READABLE,1000) & AE_READABLE) {
  68             nread = read(fd,ptr,size);
  69             if (nread <= 0) return -1;
  70             ptr += nread;
  71             size -= nread;
  72             totread += nread;
  73         }
  74         if ((time(NULL)-start) > timeout) {
  75             errno = ETIMEDOUT;
  76             return -1;
  77         }
  78     }
  79     return totread;
  80 }
  81
  82 int syncReadLine(int fd, char *ptr, ssize_t size, int timeout) {
  83     ssize_t nread = 0;
  84
  85     size--;
  86     while(size) {
  87         char c;
  88
  89         if (syncRead(fd,&c,1,timeout) == -1) return -1;
  90         if (c == '\n') {
  91             *ptr = '\0';
  92             if (nread && *(ptr-1) == '\r') *(ptr-1) = '\0';
  93             return nread;
  94         } else {
  95             *ptr++ = c;
  96             *ptr = '\0';
  97             nread++;
  98         }
  99     }
 100     return nread;
 101 }