Return to network.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / lib

Annotation of embedaddon/quagga/lib/network.c, revision 1.1.1.1

1.1       misho       1: /*
                      2:  * Network library.
                      3:  * Copyright (C) 1997 Kunihiro Ishiguro
                      4:  *
                      5:  * This file is part of GNU Zebra.
                      6:  *
                      7:  * GNU Zebra is free software; you can redistribute it and/or modify it
                      8:  * under the terms of the GNU General Public License as published by the
                      9:  * Free Software Foundation; either version 2, or (at your option) any
                     10:  * later version.
                     11:  *
                     12:  * GNU Zebra is distributed in the hope that it will be useful, but
                     13:  * WITHOUT ANY WARRANTY; without even the implied warranty of
                     14:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
                     15:  * General Public License for more details.
                     16:  *
                     17:  * You should have received a copy of the GNU General Public License
                     18:  * along with GNU Zebra; see the file COPYING.  If not, write to the Free
                     19:  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
                     20:  * 02111-1307, USA.  
                     21:  */
                     22: 
                     23: #include <zebra.h>
                     24: #include "log.h"
                     25: #include "network.h"
                     26: 
                     27: /* Read nbytes from fd and store into ptr. */
                     28: int
                     29: readn (int fd, u_char *ptr, int nbytes)
                     30: {
                     31:   int nleft;
                     32:   int nread;
                     33: 
                     34:   nleft = nbytes;
                     35: 
                     36:   while (nleft > 0) 
                     37:     {
                     38:       nread = read (fd, ptr, nleft);
                     39: 
                     40:       if (nread < 0) 
                     41:        return (nread);
                     42:       else
                     43:        if (nread == 0) 
                     44:          break;
                     45: 
                     46:       nleft -= nread;
                     47:       ptr += nread;
                     48:     }
                     49: 
                     50:   return nbytes - nleft;
                     51: }  
                     52: 
                     53: /* Write nbytes from ptr to fd. */
                     54: int
                     55: writen(int fd, const u_char *ptr, int nbytes)
                     56: {
                     57:   int nleft;
                     58:   int nwritten;
                     59: 
                     60:   nleft = nbytes;
                     61: 
                     62:   while (nleft > 0) 
                     63:     {
                     64:       nwritten = write(fd, ptr, nleft);
                     65:       
                     66:       if (nwritten <= 0) 
                     67:        return (nwritten);
                     68: 
                     69:       nleft -= nwritten;
                     70:       ptr += nwritten;
                     71:     }
                     72:   return nbytes - nleft;
                     73: }
                     74: 
                     75: int
                     76: set_nonblocking(int fd)
                     77: {
                     78:   int flags;
                     79: 
                     80:   /* According to the Single UNIX Spec, the return value for F_GETFL should
                     81:      never be negative. */
                     82:   if ((flags = fcntl(fd, F_GETFL)) < 0)
                     83:     {
                     84:       zlog_warn("fcntl(F_GETFL) failed for fd %d: %s",
                     85:                fd, safe_strerror(errno));
                     86:       return -1;
                     87:     }
                     88:   if (fcntl(fd, F_SETFL, (flags | O_NONBLOCK)) < 0)
                     89:     {
                     90:       zlog_warn("fcntl failed setting fd %d non-blocking: %s",
                     91:                fd, safe_strerror(errno));
                     92:       return -1;
                     93:     }
                     94:   return 0;
                     95: }