Home | History | Annotate | Download | only in net 
      1 //
      2 // Copyright (C) 2012 The Android Open Source Project
      3 //
      4 // Licensed under the Apache License, Version 2.0 (the "License");
      5 // you may not use this file except in compliance with the License.
      6 // You may obtain a copy of the License at
      7 //
      8 //      http://www.apache.org/licenses/LICENSE-2.0
      9 //
     10 // Unless required by applicable law or agreed to in writing, software
     11 // distributed under the License is distributed on an "AS IS" BASIS,
     12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13 // See the License for the specific language governing permissions and
     14 // limitations under the License.
     15 //
     16 
     17 #ifndef SHILL_NET_SOCKETS_H_
     18 #define SHILL_NET_SOCKETS_H_
     19 
     20 #include <linux/filter.h>
     21 #include <netinet/in.h>
     22 #include <sys/socket.h>
     23 #include <sys/types.h>
     24 
     25 #include <string>
     26 
     27 #include <base/compiler_specific.h>
     28 #include <base/macros.h>
     29 
     30 #include "shill/net/shill_export.h"
     31 
     32 namespace shill {
     33 
     34 // A "sys/socket.h" abstraction allowing mocking in tests.
     35 class SHILL_EXPORT Sockets {
     36  public:
     37   Sockets();
     38   virtual ~Sockets();
     39 
     40   static const int kInvalidFileDescriptor = -1;
     41 
     42   // accept
     43   virtual int Accept(int sockfd,
     44                      struct sockaddr* addr,
     45                      socklen_t* addrlen) const;
     46 
     47   // getsockopt(sockfd, SOL_SOCKET, SO_ATTACH_FILTER, ...)
     48   virtual int AttachFilter(int sockfd, struct sock_fprog* pf) const;
     49 
     50   // bind
     51   virtual int Bind(int sockfd,
     52                    const struct sockaddr* addr,
     53                    socklen_t addrlen) const;
     54 
     55   // setsockopt(s, SOL_SOCKET, SO_BINDTODEVICE ...)
     56   virtual int BindToDevice(int sockfd, const std::string& device) const;
     57 
     58   // setsockopt(s, SOL_SOCKET, SO_REUSEADDR, ...)
     59   virtual int ReuseAddress(int sockfd) const;
     60 
     61   // setsockopt(s, IPPROTO_IP, IP_ADD_MEMBERSHIP, ...)
     62   virtual int AddMulticastMembership(int sockfd, in_addr_t addr) const;
     63 
     64   // close
     65   virtual int Close(int fd) const;
     66 
     67   // connect
     68   virtual int Connect(int sockfd,
     69                       const struct sockaddr* addr,
     70                       socklen_t addrlen) const;
     71 
     72   // errno
     73   virtual int Error() const;
     74 
     75   // errno
     76   virtual std::string ErrorString() const;
     77 
     78   // getsockname
     79   virtual int GetSockName(int sockfd,
     80                           struct sockaddr* addr,
     81                           socklen_t* addrlen) const;
     82 
     83   // getsockopt(sockfd, SOL_SOCKET, SO_ERROR, ...)
     84   virtual int GetSocketError(int sockfd) const;
     85 
     86   // ioctl
     87   virtual int Ioctl(int d, int request, void* argp) const;
     88 
     89   // listen
     90   virtual int Listen(int sockfd, int backlog) const;
     91 
     92   // recvfrom
     93   virtual ssize_t RecvFrom(int sockfd, void* buf, size_t len, int flags,
     94                            struct sockaddr* src_addr, socklen_t* addrlen) const;
     95 
     96   // select
     97   virtual int Select(int nfds,
     98                      fd_set* readfds,
     99                      fd_set* writefds,
    100                      fd_set* exceptfds,
    101                      struct timeval* timeout) const;
    102 
    103   // send
    104   virtual ssize_t Send(int sockfd,
    105                        const void* buf,
    106                        size_t len,
    107                        int flags) const;
    108 
    109   // sendto
    110   virtual ssize_t SendTo(int sockfd,
    111                          const void* buf,
    112                          size_t len,
    113                          int flags,
    114                          const struct sockaddr* dest_addr,
    115                          socklen_t addrlen) const;
    116 
    117   // fcntl(sk, F_SETFL, fcntl(sk, F_GETFL) | O_NONBLOCK)
    118   virtual int SetNonBlocking(int sockfd) const;
    119 
    120   // setsockopt(SO_RCVBUFFORCE)
    121   virtual int SetReceiveBuffer(int sockfd, int size) const;
    122 
    123   // shutdown
    124   virtual int ShutDown(int sockfd, int how) const;
    125 
    126   // socket
    127   virtual int Socket(int domain, int type, int protocol) const;
    128 
    129  private:
    130   DISALLOW_COPY_AND_ASSIGN(Sockets);
    131 };
    132 
    133 class SHILL_EXPORT ScopedSocketCloser {
    134  public:
    135   ScopedSocketCloser(Sockets* sockets, int fd);
    136   ~ScopedSocketCloser();
    137 
    138   // Release and return the socket file descriptor, allowing the socket to
    139   // remain open as the ScopedSocketCloser is destroyed.
    140   int Release() WARN_UNUSED_RESULT;
    141 
    142  private:
    143   Sockets* sockets_;
    144   int fd_;
    145 
    146   DISALLOW_COPY_AND_ASSIGN(ScopedSocketCloser);
    147 };
    148 
    149 }  // namespace shill
    150 
    151 #endif  // SHILL_NET_SOCKETS_H_
    152