src/storage/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 void* os::mmap(void* addr, size_t len, int prot, int flags, file_desc fildes, off_t off)
  20 {
  21 #ifdef WINNT
  22         HANDLE hFile = ::CreateFileMapping(fildes,
  23                 NULL, prot, 0, off, NULL);
  24         if (hFile == NULL)
  25         {
  26                  printf("unable to do mmap\n");
  27                  return NULL;
  28         }
  29         return  ::MapViewOfFileEx(hFile, FILE_MAP_WRITE, 0, 0, off, addr);
  30 #elif defined   SOLARIS
  31     return ((void*)::mmap((char*)addr,len,prot,flags,fildes,off));
  32 #else
  33     return ((void*)::mmap(addr,len,prot,flags,fildes,off));
  34 #endif
  35 }
  36
  37 int os::munmap(caddr_t addr, size_t len)
  38 {
  39 #ifdef WINNT
  40         return ::UnmapViewOfFile(addr);
  41 #else
  42     return ::munmap(addr, len);
  43 #endif
  44 }
  45
  46 int os::atexit(void (*exitHndlr)(void))
  47 {
  48     return ::atexit(exitHndlr);
  49 }
  50
  51 shared_memory_id os::shm_create(shared_memory_key key, size_t size, int flag)
  52 {
  53 #ifdef WINNT
  54         char fName[MAX_FILE_PATH_LEN];
  55         sprintf(fName, "SHM_ID_%d", key);
  56         HANDLE hFile = ::CreateFileMapping(INVALID_HANDLE_VALUE,
  57                 NULL, PAGE_READWRITE, 0, size, NULL);
  58         if (hFile == NULL)
  59         {
  60                  printf("unable to do shm_create\n");
  61                  return -1;
  62         }
  63         return key;
  64 #else
  65     return ::shmget(key, size, IPC_CREAT | IPC_EXCL | flag);
  66 #endif
  67 }
  68
  69 shared_memory_id os::shm_open(shared_memory_key key, size_t size, int flag)
  70 {
  71 #ifdef WINNT
  72         return shm_create(key, size, flag);
  73 #else
  74     return ::shmget(key, size, flag);
  75 #endif
  76 }
  77 int os::shmctl(int shmid, int cmd)
  78 {
  79 #ifdef WINNT
  80         printf("WINDOWS shm_open not implemented\n");
  81         return 0;
  82 #else
  83     return ::shmctl(shmid, cmd, NULL);
  84 #endif
  85 }
  86 int os::shm_remove(int shmid)
  87 {
  88 #ifdef WINNT
  89         printf("WINDOWS shmremove not implemented\n");
  90         return 0;
  91 #else
  92     return ::shmctl(shmid, IPC_RMID, NULL);
  93 #endif
  94 }
  95
  96 void*  os::shm_attach(shared_memory_id id, const void *ptr, int flag)
  97 {
  98 #ifdef WINNT
  99         char fName[MAX_FILE_PATH_LEN];
 100         sprintf(fName, "SHM_ID_%d", id);
 101         HANDLE hFile = ::OpenFileMapping(FILE_MAP_ALL_ACCESS,false, fName);
 102         if (hFile == NULL)
 103         {
 104                  printf("unable to do mmap\n");
 105                  return NULL;
 106         }
 107         return  ::MapViewOfFileEx(hFile, FILE_MAP_WRITE, 0, 0, 0, (void*)ptr);
 108 #else
 109     return ::shmat(id, ptr, flag);
 110 #endif
 111 }
 112
 113 int os::shm_detach (void* addr)
 114 {
 115 #ifdef WINNT
 116         return ::UnmapViewOfFile(addr);
 117 #else
 118     return ::shmdt((char*)addr);
 119 #endif
 120 }
 121
 122 int os::gettimeofday(struct timeval *tp)
 123 {
 124     int retval=0;
 125 #ifdef WINNT
 126     FILETIME ft;
 127     unsigned __int64 tmpres = 0;
 128     GetSystemTimeAsFileTime(&ft);
 129
 130     // The GetSystemTimeAsFileTime returns the number of 100 nanosecond
 131     // intervals since Jan 1, 1601 in a structure. Copy the high bits to
 132     // the 64 bit tmpres, shift it left by 32 then or in the low 32 bits.
 133     tmpres |= ft.dwHighDateTime;
 134     tmpres <<= 32;
 135     tmpres |= ft.dwLowDateTime;
 136
 137     // Convert to microseconds by dividing by 10
 138     tmpres /= 10;
 139
 140     // The Unix epoch starts on Jan 1 1970.  Need to subtract the difference
 141     // in seconds from Jan 1 1601.
 142     tmpres -= DELTA_EPOCH_IN_MICROSECS;
 143
 144     // Finally change microseconds to seconds and place in the seconds value.
 145     // The modulus picks up the microseconds.
 146     tp->tv_sec = (long)(tmpres / 1000000UL);
 147     tp->tv_usec = (long)(tmpres % 1000000UL);
 148 #else
 149         retval=::gettimeofday(tp, NULL);
 150 #endif
 151         return retval;
 152 }
 153
 154 struct tm* os::localtime(long *secs)
 155 {
 156 #ifdef SOLARIS
 157     return (struct tm*) ::localtime(secs);
 158 #elif defined WINNT
 159     return ::localtime((const time_t*)secs);
 160 #else
 161     return ::localtime(secs);
 162 #endif
 163 }
 164 int os::open(const char *name, FileOpenMode flags, size_t size)
 165 {
 166     int retval = -1;
 167     mode_t oldMode = umask(0000);
 168     mode_t mode = (mode_t)0644 ;
 169     retval=::open(name, flags, mode);
 170     umask(oldMode);
 171     if (0 == size)
 172         return (int) retval;
 173     os::lseek(retval, size-1, SEEK_SET);
 174     char *buf = (char*)" ";
 175     os::write(retval, buf, 1);
 176     return (int) retval;
 177 }
 178 int os::close(int fd)
 179 {
 180         return ::close(fd);
 181 }
 182
 183 file_desc os::openFile(const char *name, FileOpenMode flags, size_t size)
 184 {
 185
 186 #ifdef WINNT
 187         HANDLE hFile = CreateFile(name, GENERIC_READ | GENERIC_WRITE,
 188                        FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 189
 190     if (hFile == INVALID_HANDLE_VALUE)
 191     {
 192         printf("Unable to open file %s \n", name);
 193         return (file_desc) -1;
 194     }
 195         if (0 == size)
 196         return (file_desc) hFile;
 197     mode_t mode = (mode_t)0644 ;
 198     int retval=::open(name, flags, mode);
 199     os::lseek(retval, size-1, SEEK_SET);
 200     char *buf = (char*)" ";
 201     os::write(retval, buf, 1);
 202         ::close(retval);
 203     return (file_desc) retval;
 204 #else
 205     int retval = -1;
 206     //mode_t mode = S_IRWXU | S_IRGRP | S_IWGRP ;
 207     mode_t oldMode = umask(0000);
 208     mode_t mode = (mode_t)0644 ;
 209     retval=::open(name, flags, mode);
 210     umask(oldMode);
 211     if (0 == size)
 212         return (file_desc) retval;
 213     os::lseek(retval, size-1, SEEK_SET);
 214     char *buf = (char*)" ";
 215     os::write(retval, buf, 1);
 216     return (file_desc) retval;
 217 #endif
 218 }
 219 int os::openFileForAppend(const char *name, int flag)
 220 {
 221     mode_t mode = (mode_t)0644 ;
 222     int flags = flag | O_WRONLY|O_APPEND;
 223     return  ::open(name, flags, mode);
 224 }
 225
 226 int os::closeFile(file_desc fd)
 227 {
 228 #ifdef WINNT
 229         return ::CloseHandle(fd);
 230 #else
 231     return ::close(fd);
 232 #endif
 233 }
 234 int os::lockFile(int fd)
 235 {
 236 #ifdef SOLARIS
 237     //TODO
 238         printf("SOLARIS lockFile not implemented\n");
 239     return 0;
 240 #elif defined WINNT
 241         printf("WINDOWS lockFile not implemented\n");
 242     return 0;
 243 #else
 244     return flock(fd, LOCK_EX);
 245 #endif
 246 }
 247 int os::unlockFile(int fd)
 248 {
 249 #ifdef SOLARIS
 250         printf("Solaris unlockFile not implemented\n");
 251     //TODO
 252     return 0;
 253 #elif defined WINNT
 254         printf("WINDOWS unlockFile not implemented\n");
 255     return 0;
 256 #else
 257     return ::flock(fd, LOCK_UN);
 258 #endif
 259 }
 260
 261 off_t os::lseek(int fildes, off_t offset, int whence)
 262 {
 263     return ::lseek(fildes, offset, whence);
 264 }
 265
 266 size_t os::write(int fildes, char *buf, size_t size)
 267 {
 268     return ::write(fildes, buf, size);
 269 }
 270
 271 int os::msync(caddr_t addr, size_t len, int flags)
 272 {
 273 #ifdef WINNT
 274         printf("WINDOWS msync not implemented\n");
 275         return 1;
 276 #else
 277         return ::msync(addr, len, flags);
 278 #endif
 279 }
 280 int os::fsync(int fildes)
 281 {
 282 #ifdef WINNT
 283         printf("WINDOWS fsync not implemented\n");
 284         return 0;
 285 #else
 286     return ::fsync(fildes);
 287 #endif
 288 }
 289
 290 char* os::encrypt(const char *key, const char *salt)
 291 {
 292 #ifdef WINNT
 293         printf("WINDOWS encrypt not implemented\n");
 294         return (char*)key;
 295 #else
 296     return ::crypt(key, salt);
 297 #endif
 298 }
 299
 300 void* os::memset(void *src, int c, size_t size)
 301 {
 302     return::memset(src, c, size);
 303 }
 304
 305 void* os::memcpy(void *src, const void *dest, size_t size)
 306 {
 307     return ::memcpy(src, dest, size);
 308 }
 309
 310 int os::memcmp(const void *s1, const void *s2, size_t size)
 311 {
 312     return ::memcmp(s1, s2, size);
 313 }
 314 sighandler_t os::signal(int signum, sighandler_t handler)
 315 {
 316 #ifdef WINNT
 317         printf("WINDOWS signal not implemented\n");
 318         return NULL;
 319 #else
 320         return ::signal(signum, handler);
 321 #endif
 322 }
 323
 324 int os::select(int nfds, fd_set *readfds, fd_set *writefds,
 325                  fd_set *exceptfds, struct timeval * timeout)
 326 {
 327     return ::select(nfds, readfds, writefds, exceptfds, timeout);
 328 }
 329 int os::sleep(int secs)
 330 {
 331 #ifdef WINNT
 332     ::Sleep(secs *1000);
 333         return 0;
 334 #else
 335     return ::sleep(secs);
 336 #endif
 337 }
 338 int os::usleep(int msecs)
 339 {
 340     struct timeval timeout;
 341     timeout.tv_sec = 0;
 342     timeout.tv_usec = msecs;
 343     os::select(0,0,0,0, &timeout);
 344     return 0;
 345 }
 346 int os::getFileSize(const char *fileName)
 347 {
 348     struct stat buf;
 349     stat(fileName, &buf);
 350     return buf.st_size;
 351 }
 352
 353 char* os::getenv(const char *envVarName)
 354 {
 355     char *retVal;
 356     retVal = ::getenv(envVarName);
 357     return retVal;
 358 }
 359
 360 int os::setenv(const char *envVarName, const char *value)
 361 {
 362 #ifdef SOLARIS
 363     char str[IDENTIFIER_LENGTH*3];
 364     sprintf(str, "%s=%s", envVarName, value);
 365     return putenv(str);
 366 #elif defined WINNT
 367         printf("WINDOWS setenv not implemented \n");
 368         return 0;
 369 #else
 370     return ::setenv(envVarName, value,1);
 371 #endif
 372 }
 373
 374 int os::kill(pid_t pid, int sig)
 375 {
 376 #ifdef WINNT
 377         printf("WINDOWS kill not implemented\n");
 378         return 0;
 379 #else
 380         return ::kill(pid, sig);
 381 #endif
 382 }
 383 bool os::atobool(char *value)
 384 {
 385     if (strlen(value) ==3 && strncasecmp(value,"YES",3)==0) return true;
 386     else if (strlen(value) ==2 && strncasecmp(value,"NO", 2)==0) return false;
 387     else if (strlen(value) ==4 && strncasecmp(value,"true",4)==0) return true;
 388     else if (strlen(value) ==5 && strncasecmp(value,"false",5)==0) return false;
 389     return false;
 390 }
 391 pid_t os::createProcess(const char* cmdName, const char* execName)
 392 {
 393 #if defined WINNT
 394         printf("WINDOWS: createProcess implemented partially\n");
 395         STARTUPINFO sinfo;
 396     PROCESS_INFORMATION pinfo;
 397     ZeroMemory( &sinfo, sizeof(sinfo) );
 398     sinfo.cb = sizeof(sinfo);
 399     ZeroMemory( &pinfo, sizeof(pinfo) );
 400
 401     if (!::CreateProcess(cmdName, NULL, NULL, NULL, FALSE, 0, NULL, NULL,
 402         &sinfo, &pinfo))
 403     {
 404         return -1;
 405     }
 406         return (pid_t)pinfo.dwProcessId;
 407 #else
 408     pid_t pid;
 409     pid = ::fork();
 410     if (pid == (pid_t) -1 )
 411     {
 412         printf("Process creation failed\n");
 413         return -1;
 414     }
 415     if (pid >0)
 416     {
 417         //return for parent
 418         return pid;
 419     }
 420     pid=::execl(cmdName,execName, NULL);
 421     if (pid < 0)
 422         printf("Exec failed\n");
 423     return pid;
 424 #endif
 425 }
 426 pid_t os::fork()
 427 {
 428 #if defined WINNT
 429         printf("WINDOWS: fork not implemented\n");
 430         return 0;
 431 #else
 432     return ::fork();
 433 #endif
 434 }
 435 size_t os::send(int fd, const void *buf, size_t len, int flags)
 436 {
 437     size_t totalLen = len;
 438     size_t nbytes = ::send(fd, (char*)buf, len, flags);
 439     while (nbytes != -1 && nbytes != len) {
 440         len = len - nbytes;
 441         nbytes = ::send(fd, ((char *)buf)+nbytes, len, flags);
 442     }
 443     if (nbytes == -1) return -1;
 444     else return totalLen;
 445 }
 446 size_t os::recv(int fd, void *buf, size_t len, int flags)
 447 {
 448     size_t totalLen = len;
 449     size_t nbytes = ::recv(fd, (char*)buf, len, flags);
 450     if (!nbytes) return 0;
 451     while (nbytes != -1 && nbytes != len) {
 452         len = len - nbytes;
 453         nbytes = ::recv(fd, ((char *)buf)+nbytes, len, flags);
 454     }
 455     if (nbytes == -1) return -1;
 456     else return totalLen;
 457 }
 458 int os::gethostname(char *hostname, size_t len)
 459 {
 460     return ::gethostname(hostname, len);
 461 }
 462 int os::strmatch(char *pattern, char *str)
 463 {
 464 #if defined WINNT
 465         printf("WINDOWS: strmatch not implemented\n");
 466         return 0;
 467 #else
 468         return ::fnmatch(pattern, str, 0);
 469 #endif
 470 }
 471
 472 int os::msgget(key_t key, int oflag)
 473 {
 474 #if defined WINNT
 475         printf("WINDOWS: msgget not implemented\n");
 476         return 0;
 477 #else
 478     return ::msgget(key, oflag | IPC_CREAT);
 479 #endif
 480 }
 481
 482 int os::msgsnd(int msqid, const void *ptr, size_t len, int flag)
 483 {
 484 #if defined WINNT
 485         printf("WINDOWS: msgsnd not implemented\n");
 486         return 0;
 487 #else
 488     return ::msgsnd(msqid, ptr, len, flag);
 489 #endif
 490 }
 491
 492 int os::msgrcv(int msqid, void *ptr, size_t len, long type, int flag)
 493 {
 494 #if defined WINNT
 495         printf("WINDOWS: msgrcv not implemented\n");
 496         return 0;
 497 #else
 498     return ::msgrcv(msqid, ptr, len, type, flag);
 499 #endif
 500 };
 501
 502 int os::msgctl(int msqid, int cmd, struct msqid_ds *buff)
 503 {
 504 #if defined WINNT
 505         printf("WINDOWS: msgctl not implemented\n");
 506         return 0;
 507 #else
 508     return ::msgctl(msqid, cmd, buff);
 509 #endif
 510 }
 511 bool os::fileExists(char *fileName)
 512 {
 513 #if defined WINNT
 514         int ret = _access(fileName, 04);
 515         if (0 == ret) return true; else return false;
 516 #else
 517     int ret = access(fileName, R_OK);
 518     if (0 == ret) return true; else return false;
 519 #endif
 520 }
 521 int os::isValidIP(char ipstr[] )
 522 {
 523 #if defined(LINUX)
 524     struct ifaddrs * ifAddrStruct=NULL;
 525     void * tmpAddrPtr=NULL;
 526     char  addressBuffer[100];
 527     int i=0;
 528     getifaddrs(&ifAddrStruct);
 529
 530     while (ifAddrStruct!=NULL)
 531     {
 532             if (ifAddrStruct->ifa_addr->sa_family==AF_INET && strcmp(ifAddrStruct->ifa_name, "lo0")!=0)
 533             {
 534                 tmpAddrPtr=&((struct sockaddr_in *)ifAddrStruct->ifa_addr)->sin_addr;
 535                 inet_ntop(AF_INET, tmpAddrPtr, addressBuffer, 100);
 536                 if(strcmp(ipstr,addressBuffer) == 0)
 537                 {
 538           //         printf("\nThe ip is matched %s and %s",ipstr,addressBuffer);
 539                     return 1;
 540                 }
 541              //   printf("IP Address %s\n", inet_ntop(AF_INET, tmpAddrPtr, addressBuffer, 100));
 542             }
 543             ifAddrStruct=ifAddrStruct->ifa_next;
 544     }
 545 #endif
 546     return 0;
 547 }
 548 char* os::strcasestr(char *str1, const char *str2)
 549 {
 550 #if defined(LINUX)
 551     return ::strcasestr(str1, str2);
 552 #else
 553     return ::strstr(str1, str2);
 554     /*
 555     int size=strlen(str1);
 556     char *tmpStr=new char[size];
 557     char *tmpStrPtr=NULL;
 558     strcpy(tmpStr, str1);
 559     tmpStrPtr=tmpStr;
 560     while(*tmpStrPtr != '\0')
 561     {
 562         *tmpStrPtr=::toupper(*tmpStrPtr);
 563         tmpStrPtr++;
 564     }
 565     char *subStrPtr = ::strstr(tmpStr, str2);
 566     delete []tmpStr;
 567     return subStrPtr;
 568     */
 569 #endif
 570 }
 571 int os::getNoOfProcessors()
 572 {
 573 #if defined WINNT
 574         printf("WINDOWS: getNoOfProcessors not implemented\n");
 575         return 1;
 576 #else
 577     return ::sysconf(_SC_NPROCESSORS_ONLN);
 578 #endif
 579 }
 580 mode_t os::umask(mode_t mask)
 581 {
 582     return::umask(mask);
 583 }
 584 int os::fdatasync(file_desc fd)
 585 {
 586 #ifdef FreeBSD
 587     return ::fsync(fd);
 588 #elif defined WINNT
 589         printf("WINDOWS: fdatasync not implemented\n");
 590         return 0;
 591 #else
 592     return ::fdatasync(fd);
 593 #endif
 594 }
 595 pid_t os::getpid()
 596 {
 597 #ifdef WINNT
 598     return ::GetCurrentThreadId();
 599 #else
 600         return ::getpid();
 601 #endif
 602 }
 603 pthread_t os::getthrid()
 604 {
 605 #ifdef WINNT
 606     return ::GetCurrentThreadId();
 607 #else
 608         return ::pthread_self();
 609 #endif
 610 }
 611
 612 int os::truncate(const char* filename)
 613 {
 614 #ifdef WINNT
 615     int fh, result=0;
 616     if (fh = ::_open(filename, _O_RDWR) == 0)
 617     {
 618        result = _chsize(fh, 0);
 619            ::_close(fh);
 620     }
 621         return result;
 622 #else
 623         return ::truncate(filename, 0);
 624 #endif
 625 }
 626
 627 void* os::dlsym(LHANDLE hdl, char *fname)
 628 {
 629 #ifdef WINNT
 630         return ::GetProcAddress(hdl, fname);
 631 #else
 632         return ::dlsym(hdl, fname);
 633 #endif
 634 }
 635