1 /***************************************************************************
2 * Copyright (C) 2007 by www.databasecache.com *
3 * Contact: praba_tuty@databasecache.com *
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. *
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. *
15 ***************************************************************************/
19 void* os::mmap(void* addr
, size_t len
, int prot
, int flags
, file_desc fildes
, off_t off
)
22 HANDLE hFile
= ::CreateFileMapping(fildes
,
23 NULL
, prot
, 0, off
, NULL
);
26 printf("unable to do mmap\n");
29 return ::MapViewOfFileEx(hFile
, FILE_MAP_WRITE
, 0, 0, off
, addr
);
31 return ((void*)::mmap((char*)addr
,len
,prot
,flags
,fildes
,off
));
33 return ((void*)::mmap(addr
,len
,prot
,flags
,fildes
,off
));
37 int os::munmap(caddr_t addr
, size_t len
)
40 return ::UnmapViewOfFile(addr
);
42 return ::munmap(addr
, len
);
46 int os::atexit(void (*exitHndlr
)(void))
48 return ::atexit(exitHndlr
);
51 shared_memory_id
os::shm_create(shared_memory_key key
, size_t size
, int flag
)
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
);
60 printf("unable to do shm_create\n");
65 return ::shmget(key
, size
, IPC_CREAT
| IPC_EXCL
| flag
);
69 shared_memory_id
os::shm_open(shared_memory_key key
, size_t size
, int flag
)
72 return shm_create(key
, size
, flag
);
74 return ::shmget(key
, size
, flag
);
77 int os::shmctl(int shmid
, int cmd
)
80 printf("WINDOWS shm_open not implemented\n");
83 return ::shmctl(shmid
, cmd
, NULL
);
86 int os::shm_remove(int shmid
)
89 printf("WINDOWS shmremove not implemented\n");
92 return ::shmctl(shmid
, IPC_RMID
, NULL
);
96 void* os::shm_attach(shared_memory_id id
, const void *ptr
, int flag
)
99 char fName
[MAX_FILE_PATH_LEN
];
100 sprintf(fName
, "SHM_ID_%d", id
);
101 HANDLE hFile
= ::OpenFileMapping(FILE_MAP_ALL_ACCESS
,false, (LPCWSTR
)fName
);
104 printf("unable to do mmap\n");
107 return ::MapViewOfFileEx(hFile
, FILE_MAP_WRITE
, 0, 0, 0, (void*)ptr
);
109 return ::shmat(id
, ptr
, flag
);
113 int os::shm_detach (void* addr
)
116 return ::UnmapViewOfFile(addr
);
118 return ::shmdt((char*)addr
);
122 int os::gettimeofday(struct timeval
*tp
)
127 unsigned __int64 tmpres
= 0;
128 GetSystemTimeAsFileTime(&ft
);
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
;
135 tmpres
|= ft
.dwLowDateTime
;
137 // Convert to microseconds by dividing by 10
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
;
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);
149 retval
=::gettimeofday(tp
, NULL
);
154 struct tm
* os::localtime(long *secs
)
157 return (struct tm
*) ::localtime(secs
);
159 return ::localtime((const time_t*)secs
);
161 return ::localtime(secs
);
164 int os::open(const char *name
, FileOpenMode flags
, size_t size
)
167 mode_t oldMode
= umask(0000);
168 mode_t mode
= (mode_t
)0644 ;
169 retval
=::open(name
, flags
, mode
);
173 os::lseek(retval
, size
-1, SEEK_SET
);
174 char *buf
= (char*)" ";
175 os::write(retval
, buf
, 1);
178 int os::close(int fd
)
182 int os::closeSocket(int fd
)
185 return ::closesocket(fd
);
191 file_desc
os::openFile(const char *name
, FileOpenMode flags
, size_t size
)
195 HANDLE hFile
= CreateFile((LPCWSTR
)name
, GENERIC_READ
| GENERIC_WRITE
,
196 FILE_SHARE_WRITE
, NULL
, OPEN_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
198 if (hFile
== INVALID_HANDLE_VALUE
)
200 printf("Unable to open file %s \n", name
);
201 return (file_desc
) -1;
204 return (file_desc
) hFile
;
205 mode_t mode
= (mode_t
)0644 ;
206 int retval
=::open(name
, flags
, mode
);
207 os::lseek(retval
, size
-1, SEEK_SET
);
208 char *buf
= (char*)" ";
209 os::write(retval
, buf
, 1);
211 return (file_desc
) retval
;
214 //mode_t mode = S_IRWXU | S_IRGRP | S_IWGRP ;
215 mode_t oldMode
= umask(0000);
216 mode_t mode
= (mode_t
)0644 ;
217 retval
=::open(name
, flags
, mode
);
220 return (file_desc
) retval
;
221 os::lseek(retval
, size
-1, SEEK_SET
);
222 char *buf
= (char*)" ";
223 os::write(retval
, buf
, 1);
224 return (file_desc
) retval
;
227 int os::openFileForAppend(const char *name
, int flag
)
229 mode_t mode
= (mode_t
)0644 ;
230 int flags
= flag
| O_WRONLY
|O_APPEND
;
231 return ::open(name
, flags
, mode
);
234 int os::closeFile(file_desc fd
)
237 return ::CloseHandle(fd
);
242 int os::lockFile(int fd
)
246 printf("SOLARIS lockFile not implemented\n");
249 printf("WINDOWS lockFile not implemented\n");
252 return flock(fd
, LOCK_EX
);
255 int os::unlockFile(int fd
)
258 printf("Solaris unlockFile not implemented\n");
262 printf("WINDOWS unlockFile not implemented\n");
265 return ::flock(fd
, LOCK_UN
);
269 off_t
os::lseek(int fildes
, off_t offset
, int whence
)
271 return ::lseek(fildes
, offset
, whence
);
274 size_t os::write(int fildes
, char *buf
, size_t size
)
276 return ::write(fildes
, buf
, size
);
279 int os::msync(caddr_t addr
, size_t len
, int flags
)
282 printf("WINDOWS msync not implemented\n");
285 return ::msync(addr
, len
, flags
);
288 int os::fsync(int fildes
)
291 printf("WINDOWS fsync not implemented\n");
294 return ::fsync(fildes
);
298 char* os::encrypt(const char *key
, const char *salt
)
301 printf("WINDOWS encrypt not implemented\n");
304 return ::crypt(key
, salt
);
308 void* os::memset(void *src
, int c
, size_t size
)
310 return::memset(src
, c
, size
);
313 void* os::memcpy(void *src
, const void *dest
, size_t size
)
315 return ::memcpy(src
, dest
, size
);
318 int os::memcmp(const void *s1
, const void *s2
, size_t size
)
320 return ::memcmp(s1
, s2
, size
);
322 sighandler_t
os::signal(int signum
, sighandler_t handler
)
325 printf("WINDOWS signal not implemented\n");
328 return ::signal(signum
, handler
);
332 int os::select(int nfds
, fd_set
*readfds
, fd_set
*writefds
,
333 fd_set
*exceptfds
, struct timeval
* timeout
)
335 return ::select(nfds
, readfds
, writefds
, exceptfds
, timeout
);
337 int os::sleep(int secs
)
343 return ::sleep(secs
);
346 int os::usleep(int msecs
)
348 struct timeval timeout
;
350 timeout
.tv_usec
= msecs
;
351 os::select(0,0,0,0, &timeout
);
354 int os::getFileSize(const char *fileName
)
357 stat(fileName
, &buf
);
361 char* os::getenv(const char *envVarName
)
364 retVal
= ::getenv(envVarName
);
368 int os::setenv(const char *envVarName
, const char *value
)
371 char str
[IDENTIFIER_LENGTH
*3];
372 sprintf(str
, "%s=%s", envVarName
, value
);
375 printf("WINDOWS setenv not implemented \n");
378 return ::setenv(envVarName
, value
,1);
382 int os::kill(pid_t pid
, int sig
)
385 printf("WINDOWS kill not implemented\n");
388 return ::kill(pid
, sig
);
391 bool os::atobool(char *value
)
393 if (strlen(value
) ==3 && strncasecmp(value
,"YES",3)==0) return true;
394 else if (strlen(value
) ==2 && strncasecmp(value
,"NO", 2)==0) return false;
395 else if (strlen(value
) ==4 && strncasecmp(value
,"true",4)==0) return true;
396 else if (strlen(value
) ==5 && strncasecmp(value
,"false",5)==0) return false;
399 pid_t
os::createProcess(const char* cmdName
, const char* execName
)
402 printf("WINDOWS: createProcess implemented partially\n");
404 PROCESS_INFORMATION pinfo
;
405 ZeroMemory( &sinfo
, sizeof(sinfo
) );
406 sinfo
.cb
= sizeof(sinfo
);
407 ZeroMemory( &pinfo
, sizeof(pinfo
) );
409 if (!::CreateProcess((LPCWSTR
)cmdName
, NULL
, NULL
, NULL
, FALSE
, 0, NULL
, NULL
,
414 return (pid_t
)pinfo
.dwProcessId
;
418 if (pid
== (pid_t
) -1 )
420 printf("Process creation failed\n");
428 pid
=::execl(cmdName
,execName
, NULL
);
430 printf("Exec failed\n");
437 printf("WINDOWS: fork not implemented\n");
443 size_t os::send(int fd
, const void *buf
, size_t len
, int flags
)
445 size_t totalLen
= len
;
446 size_t nbytes
= ::send(fd
, (char*)buf
, len
, flags
);
447 while (nbytes
!= -1 && nbytes
!= len
) {
449 nbytes
= ::send(fd
, ((char *)buf
)+nbytes
, len
, flags
);
451 if (nbytes
== -1) return -1;
452 else return totalLen
;
454 size_t os::recv(int fd
, void *buf
, size_t len
, int flags
)
456 size_t totalLen
= len
;
457 size_t nbytes
= ::recv(fd
, (char*)buf
, len
, flags
);
458 if (!nbytes
) return 0;
459 while (nbytes
!= -1 && nbytes
!= len
) {
461 nbytes
= ::recv(fd
, ((char *)buf
)+nbytes
, len
, flags
);
463 if (nbytes
== -1) return -1;
464 else return totalLen
;
466 int os::gethostname(char *hostname
, size_t len
)
468 return ::gethostname(hostname
, len
);
470 int os::strmatch(char *pattern
, char *str
)
473 printf("WINDOWS: strmatch not implemented\n");
476 return ::fnmatch(pattern
, str
, 0);
480 int os::msgget(key_t key
, int oflag
)
483 printf("WINDOWS: msgget not implemented\n");
486 return ::msgget(key
, oflag
| IPC_CREAT
);
490 int os::msgsnd(int msqid
, const void *ptr
, size_t len
, int flag
)
493 printf("WINDOWS: msgsnd not implemented\n");
496 return ::msgsnd(msqid
, ptr
, len
, flag
);
500 int os::msgrcv(int msqid
, void *ptr
, size_t len
, long type
, int flag
)
503 printf("WINDOWS: msgrcv not implemented\n");
506 return ::msgrcv(msqid
, ptr
, len
, type
, flag
);
510 int os::msgctl(int msqid
, int cmd
, struct msqid_ds
*buff
)
513 printf("WINDOWS: msgctl not implemented\n");
516 return ::msgctl(msqid
, cmd
, buff
);
519 bool os::fileExists(char *fileName
)
522 int ret
= _access(fileName
, 04);
523 if (0 == ret
) return true; else return false;
525 int ret
= access(fileName
, R_OK
);
526 if (0 == ret
) return true; else return false;
529 int os::isValidIP(char ipstr
[] )
532 struct ifaddrs
* ifAddrStruct
=NULL
;
533 void * tmpAddrPtr
=NULL
;
534 char addressBuffer
[100];
536 getifaddrs(&ifAddrStruct
);
538 while (ifAddrStruct
!=NULL
)
540 if (ifAddrStruct
->ifa_addr
->sa_family
==AF_INET
&& strcmp(ifAddrStruct
->ifa_name
, "lo0")!=0)
542 tmpAddrPtr
=&((struct sockaddr_in
*)ifAddrStruct
->ifa_addr
)->sin_addr
;
543 inet_ntop(AF_INET
, tmpAddrPtr
, addressBuffer
, 100);
544 if(strcmp(ipstr
,addressBuffer
) == 0)
546 // printf("\nThe ip is matched %s and %s",ipstr,addressBuffer);
549 // printf("IP Address %s\n", inet_ntop(AF_INET, tmpAddrPtr, addressBuffer, 100));
551 ifAddrStruct
=ifAddrStruct
->ifa_next
;
556 char* os::strcasestr(char *str1
, const char *str2
)
559 return ::strcasestr(str1
, str2
);
561 return ::strstr(str1
, str2
);
563 int size=strlen(str1);
564 char *tmpStr=new char[size];
565 char *tmpStrPtr=NULL;
566 strcpy(tmpStr, str1);
568 while(*tmpStrPtr != '\0')
570 *tmpStrPtr=::toupper(*tmpStrPtr);
573 char *subStrPtr = ::strstr(tmpStr, str2);
579 int os::getNoOfProcessors()
582 printf("WINDOWS: getNoOfProcessors not implemented\n");
585 return ::sysconf(_SC_NPROCESSORS_ONLN
);
588 mode_t
os::umask(mode_t mask
)
592 int os::fdatasync(file_desc fd
)
597 printf("WINDOWS: fdatasync not implemented\n");
600 return ::fdatasync(fd
);
606 return ::GetCurrentThreadId();
611 pthread_t
os::getthrid()
614 return ::GetCurrentThreadId();
616 return ::pthread_self();
620 int os::truncate(const char* filename
)
624 if (fh
= ::_open(filename
, _O_RDWR
) == 0)
626 result
= _chsize(fh
, 0);
631 return ::truncate(filename
, 0);
635 void* os::dlsym(LHANDLE hdl
, char *fname
)
638 return ::GetProcAddress(hdl
, fname
);
640 return ::dlsym(hdl
, fname
);