src/server/os.cxx

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by www.databasecache.com                           *
   3  *   Contact: praba_tuty@databasecache.com                                 *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15   ***************************************************************************/
  16 #include <os.h>
  17 #include <Debug.h>
  18
  19 caddr_t os::mmap(caddr_t addr, size_t len, int prot, int flags, int fildes, off_t off)
  20 {
  21     return ((caddr_t)::mmap(addr,len,prot,flags,fildes,off));
  22 }
  23
  24 int os::munmap(caddr_t addr, size_t len)
  25 {
  26     return ::munmap(addr, len);
  27 }
  28
  29
  30 shared_memory_id os::shm_create(shared_memory_key key, size_t size, int flag)
  31 {
  32     return ::shmget(key, size, IPC_CREAT | flag);
  33 }
  34
  35 shared_memory_id os::shm_open(shared_memory_key key, size_t size, int flag)
  36 {
  37     return ::shmget(key, size, flag);
  38 }
  39 int os::shmctl(int shmid, int cmd)
  40 {
  41     return ::shmctl(shmid, cmd, NULL);
  42 }
  43
  44 void*  os::shm_attach(shared_memory_id id, const void *ptr, int flag)
  45 {
  46     return ::shmat(id, ptr, flag);
  47 }
  48
  49 int os::shm_detach (void* addr)
  50 {
  51     return ::shmdt((char*)addr);
  52 }
  53
  54 double os::floor(double val)
  55 {
  56     return ::floor(val);
  57 }
  58
  59 int os::gettimeofday(struct timeval *tp)
  60 {
  61     int retval;
  62     retval=::gettimeofday(tp, NULL);
  63     return retval;
  64 }
  65
  66 struct tm* os::localtime(long *secs)
  67 {
  68     return ::localtime(secs);
  69 }
  70
  71 pid_t os::getpid()
  72 {
  73     return ::getpid();
  74 }
  75 pthread_t os::getthrid()
  76 {
  77     return ::pthread_self();
  78 }
  79
  80
  81
  82
  83 int os::openFile(const char *name, FileOpenMode flags, size_t size)
  84 {
  85     int retval = -1;
  86     //mode_t mode = S_IRWXU | S_IRGRP | S_IWGRP ;
  87     mode_t mode = (mode_t)0755 ;
  88     retval=::open(name, flags, mode);
  89     if (0 == size)
  90         return retval;
  91     os::lseek(retval, size-1, SEEK_SET);
  92     char *buf = (char*)" ";
  93     os::write(retval, buf, 1);
  94     return retval;
  95 }
  96
  97 int os::closeFile(int fd)
  98 {
  99     return ::close(fd);
 100 }
 101
 102 off_t os::lseek(int fildes, off_t offset, int whence)
 103 {
 104     return ::lseek(fildes, offset, whence);
 105 }
 106
 107 size_t os::write(int fildes, char *buf, size_t size)
 108 {
 109     return ::write(fildes, buf, size);
 110 }
 111
 112 int os::msync(caddr_t addr, size_t len, int flags)
 113 {
 114     return ::msync(addr, len, flags);
 115 }
 116 int os::fsync(int fildes)
 117 {
 118     return ::fsync(fildes);
 119 }
 120
 121 char* os::encrypt(const char *key, const char *salt)
 122 {
 123     return ::crypt(key, salt);
 124 }
 125
 126 void* os::memset(void *src, int c, size_t size)
 127 {
 128     return::memset(src, c, size);
 129 }
 130
 131 void* os::memcpy(void *src, const void *dest, size_t size)
 132 {
 133     return ::memcpy(src, dest, size);
 134 }
 135
 136 int os::memcmp(const void *s1, const void *s2, size_t size)
 137 {
 138     return ::memcmp(s1, s2, size);
 139 }
 140 sighandler_t os::signal(int signum, sighandler_t handler)
 141 {
 142     return ::signal(signum, handler);
 143 }
 144
 145 size_t os::alignLong(size_t size)
 146 {
 147     return ((size - 1) | (sizeof(long) - 1)) + 1;
 148 }
 149
 150 size_t os::align(size_t size)
 151 {
 152     //Calls alignLong
 153     return ((size - 1) | (sizeof(long) - 1)) + 1;
 154 }
 155
 156 int os::select(int nfds, fd_set *readfds, fd_set *writefds,
 157                  fd_set *exceptfds, struct timeval * timeout)
 158 {
 159     return ::select(nfds, readfds, writefds, exceptfds, timeout);
 160 }
 161
 162
 163 char* os::getenv(const char *envVarName)
 164 {
 165     char *retVal;
 166     retVal = ::getenv(envVarName);
 167     return retVal;
 168 }
 169
 170 int os::setenv(const char *envVarName, const char *value)
 171 {
 172     return ::setenv(envVarName, value,1);
 173 }
 174
 175 int os::kill(pid_t pid, int sig)
 176 {
 177     return ::kill(pid, sig);
 178 }