Home | History | Annotate | Download | only in nacl_io 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef LIBRARIES_NACL_IO_KERNEL_HANDLE_H_
      6 #define LIBRARIES_NACL_IO_KERNEL_HANDLE_H_
      7 
      8 #include <fcntl.h>
      9 #include <pthread.h>
     10 #include <ppapi/c/pp_resource.h>
     11 
     12 #include "nacl_io/error.h"
     13 #include "nacl_io/filesystem.h"
     14 #include "nacl_io/node.h"
     15 #include "nacl_io/ossocket.h"
     16 #include "nacl_io/ostypes.h"
     17 
     18 #include "sdk_util/macros.h"
     19 #include "sdk_util/ref_object.h"
     20 #include "sdk_util/scoped_ref.h"
     21 #include "sdk_util/simple_lock.h"
     22 
     23 namespace nacl_io {
     24 
     25 class SocketNode;
     26 
     27 // HandleAttr struct is passed the Node in calls
     28 // to Read and Write.  It contains handle specific state
     29 // such as the file offset and the open flags.
     30 struct HandleAttr {
     31   HandleAttr() : offs(0), flags(0) {}
     32   bool IsBlocking() const { return !(flags & O_NONBLOCK); }
     33 
     34   off_t offs;
     35   int flags;
     36 };
     37 
     38 // KernelHandle provides a reference counted container for the open
     39 // file information, such as it's filesystem, node, access type and offset.
     40 // KernelHandle can only be referenced when the KernelProxy lock is held.
     41 class KernelHandle : public sdk_util::RefObject {
     42  public:
     43   KernelHandle();
     44   KernelHandle(const ScopedFilesystem& fs, const ScopedNode& node);
     45   ~KernelHandle();
     46 
     47   Error Init(int open_flags);
     48 
     49   Error Accept(PP_Resource* new_sock, struct sockaddr* addr, socklen_t* len);
     50   Error Connect(const struct sockaddr* addr, socklen_t len);
     51   Error Fcntl(int request, int* result, ...);
     52   Error VFcntl(int request, int* result, va_list args);
     53   Error GetDents(struct dirent* pdir, size_t count, int* bytes_written);
     54   Error Read(void* buf, size_t nbytes, int* bytes_read);
     55   Error Recv(void* buf, size_t len, int flags, int* out_len);
     56   Error RecvFrom(void* buf,
     57                  size_t len,
     58                  int flags,
     59                  struct sockaddr* src_addr,
     60                  socklen_t* addrlen,
     61                  int* out_len);
     62   // Assumes |out_offset| is non-NULL.
     63   Error Seek(off_t offset, int whence, off_t* out_offset);
     64   Error Send(const void* buf, size_t len, int flags, int* out_len);
     65   Error SendTo(const void* buf,
     66                size_t len,
     67                int flags,
     68                const struct sockaddr* dest_addr,
     69                socklen_t addrlen,
     70                int* out_len);
     71   Error Write(const void* buf, size_t nbytes, int* bytes_written);
     72 
     73   const ScopedNode& node() { return node_; }
     74   const ScopedFilesystem& filesystem() { return filesystem_; }
     75 
     76   const HandleAttr& Attr() { return handle_attr_; }
     77 
     78   int OpenMode() { return handle_attr_.flags & 3; }
     79 
     80  private:
     81   // Returns the SocketNode* if this node is a socket otherwise returns
     82   // NULL.
     83   SocketNode* socket_node();
     84 
     85   ScopedFilesystem filesystem_;
     86   ScopedNode node_;
     87   sdk_util::SimpleLock handle_lock_;
     88   HandleAttr handle_attr_;
     89 
     90   friend class KernelProxy;
     91   DISALLOW_COPY_AND_ASSIGN(KernelHandle);
     92 };
     93 
     94 typedef sdk_util::ScopedRef<KernelHandle> ScopedKernelHandle;
     95 
     96 }  // namespace nacl_io
     97 
     98 #endif  // LIBRARIES_NACL_IO_KERNEL_HANDLE_H_
     99