Update copyright to LGPL on all files
[dyninst.git] / common / h / solarisHeaders.h
1 /*
2  * Copyright (c) 1996-2009 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31
32
33 #if !defined(_solaris_headers_h)
34 #define _solaris_headers_h
35
36 #include <assert.h>
37 #include <stdio.h>
38 #include <string.h>
39 #include <stdlib.h>
40 #include <errno.h>
41 #include <assert.h>
42 #include <fcntl.h>
43 #include <netinet/in.h>
44 #include <netdb.h>
45 #include <sys/types.h>
46 #include <sys/mman.h>
47 #include <sys/time.h>
48 #include <unistd.h>
49 #include <sys/file.h>
50 #include <sys/socket.h>
51 #include <sys/errno.h>
52 #include <sys/wait.h>
53 #include <signal.h>
54 #include <sys/resource.h>
55 #include <stdarg.h>
56 #include <time.h>
57 #include <sys/utsname.h>
58 #include <sys/stat.h>
59 #include <sys/un.h>
60
61 #include <rpc/types.h>
62 #include <rpc/xdr.h>
63
64 #define PDSOCKET_ERROR (-1)
65 typedef int PDSOCKET;
66 typedef int (*P_xdrproc_t)(XDR*, ...);
67 extern const char *sys_errlist[];
68
69 extern int (*P_native_demangle)(const char *, char *, size_t);
70
71 extern "C" int rexec(char **, unsigned short, const char *,
72                      const char *, const char *, int *);
73
74 /* POSIX */
75 inline int P_getopt(int argc, char *argv[], const char *optstring) { return getopt(argc, argv, optstring);}
76 inline void P_abort (void) { abort();}
77 inline int P_close (int FILEDES) { return (close(FILEDES));}
78 inline int P_dup2 (int OLD, int NEW) { return (dup2(OLD, NEW));}
79 inline int P_execvp (const char *FILENAME, char *const ARGV[]) {
80   return (execvp(FILENAME, ARGV));}
81 inline int P_execve (const char* FILENAME,
82                      char* const ARGV[], char* const ENVP[]) {
83     return (execve(FILENAME, ARGV, ENVP));
84 }
85 inline void P__exit (int STATUS) { _exit(STATUS);}
86 inline int P_fcntl (int FILEDES, int COMMAND, int ARG2) {
87   return (fcntl(FILEDES, COMMAND, ARG2));}
88 inline FILE * P_fdopen (int FILEDES, const char *OPENTYPE) {
89   return (fdopen(FILEDES, OPENTYPE));}
90 inline FILE * P_fopen (const char *FILENAME, const char *OPENTYPE) {
91   return (fopen(FILENAME, OPENTYPE));}
92 inline int P_fstat (int FILEDES, struct stat *BUF) { return (fstat(FILEDES, BUF));}
93 inline pid_t P_getpid () { return (getpid());}
94 inline int P_kill(pid_t PID, int SIGNUM) { return (kill(PID, SIGNUM));}
95 inline off_t P_lseek (int FILEDES, off_t OFFSET, int WHENCE) {
96   return (lseek(FILEDES, OFFSET, WHENCE));}
97 inline int P_open(const char *FILENAME, int FLAGS, mode_t MODE) {
98   return (open(FILENAME, FLAGS, MODE));}
99 inline int P_pclose (FILE *STREAM) { return (pclose(STREAM));}
100 inline FILE *P_popen (const char *COMMAND, const char *MODE) {
101   return (popen(COMMAND, MODE));}
102 inline size_t P_read (int FILEDES, void *BUFFER, size_t SIZE) {
103   return (read(FILEDES, BUFFER, SIZE));}
104 inline int P_uname(struct utsname *un) { return (uname(un));}
105 inline pid_t P_wait(int *status_ptr) { return (wait(status_ptr));}
106 inline int P_waitpid(pid_t pid, int *statusp, int options) {
107   return (waitpid(pid, statusp, options));}
108 inline size_t P_write (int FILEDES, const void *BUFFER, size_t SIZE) {
109   return (write(FILEDES, BUFFER, SIZE));}
110 inline int P_chdir(const char *path) { return (chdir(path)); }
111 inline int P_putenv(char *str) { return putenv(str); }
112
113 /* SYSTEM-V shared memory */
114 #include <sys/ipc.h>
115 #include <sys/shm.h> /* shmid_ds */
116 inline int P_shmget(key_t theKey, int size, int flags) {
117    return shmget(theKey, size, flags);
118 }
119 inline void *P_shmat(int shmid, void *addr, int flags) {
120    return shmat(shmid, (char *)addr, flags);
121 }
122 inline int P_shmdt(void *addr) {return shmdt((char*)addr);}
123 inline int P_shmctl(int shmid, int cmd, struct shmid_ds *buf) {
124    return shmctl(shmid, cmd, buf);
125 }
126
127 /* ANSI */
128 inline void P_exit (int STATUS) { exit(STATUS);}
129 inline int P_fflush(FILE *stream) { return (fflush(stream));}
130 inline char * P_fgets (char *S, int COUNT, FILE *STREAM) {
131   return (fgets(S, COUNT, STREAM));}
132 inline void * P_malloc (size_t SIZE) { return (malloc(SIZE));}
133 extern void * P_memcpy (void *A1, const void *A2, size_t SIZE);
134 inline void * P_memset (void *BLOCK, int C, size_t SIZE) {
135   return (memset(BLOCK, C, SIZE));}
136 inline void P_perror (const char *MESSAGE) { perror(MESSAGE);}
137 extern "C" {
138 typedef void (*P_sig_handler)(int);
139 }
140 inline P_sig_handler P_signal (int SIGNUM, P_sig_handler ACTION) {
141   return (signal(SIGNUM, ACTION));}
142 inline char * P_strcat (char *TO, const char *FROM) {
143   return (strcat(TO, FROM));}
144
145 inline const char * P_strchr (const char *P_STRING, int C) {return (strchr(P_STRING, C));}
146 inline char * P_strchr (char *P_STRING, int C) {return (strchr(P_STRING, C));}
147
148 inline int P_strcmp (const char *S1, const char *S2) {
149   return (strcmp(S1, S2));}
150 inline char * P_strcpy (char *TO, const char *FROM) {
151   return (strcpy(TO, FROM));}
152 inline char *P_strdup(const char *S) { return (strdup(S));}
153 inline size_t P_strlen (const char *S) { return (strlen(S));}
154 inline char * P_strncat (char *TO, const char *FROM, size_t SIZE) {
155   return (strncat(TO, FROM, SIZE)); }
156 inline int P_strncmp (const char *S1, const char *S2, size_t SIZE) {
157   return (strncmp(S1, S2, SIZE));}
158 inline char * P_strncpy (char *TO, const char *FROM, size_t SIZE) {
159   return (strncpy(TO, FROM, SIZE));}
160
161 inline const char * P_strrchr (const char *P_STRING, int C) {return (strrchr(P_STRING, C));}
162 inline char * P_strrchr (char *P_STRING, int C) {return (strrchr(P_STRING, C));}
163
164 inline const char * P_strstr (const char *HAYSTACK, const char *NEEDLE) {return (strstr(HAYSTACK, NEEDLE));}
165 inline char * P_strstr (char *HAYSTACK, const char *NEEDLE) {return (strstr(HAYSTACK, NEEDLE));}
166
167 inline double P_strtod (const char *P_STRING, char **TAILPTR) {
168   return (strtod(P_STRING, TAILPTR));}
169 inline char * P_strtok (char *NEWP_STRING, const char *DELIMITERS) {
170   return (strtok(NEWP_STRING, DELIMITERS));}
171 inline long int P_strtol (const char *P_STRING, char **TAILPTR, int BASE) {
172   return (strtol(P_STRING, TAILPTR, BASE));}
173 inline unsigned long int P_strtoul(const char *P_STRING, char **TAILPTR, int BASE) { 
174   return (strtoul(P_STRING, TAILPTR, BASE));}
175
176 /* BSD */
177 inline int P_accept (int SOCK, struct sockaddr *ADDR, size_t *LENGTH_PTR) {
178   return (accept(SOCK, ADDR, LENGTH_PTR));}
179 inline int P_bind(int socket, struct sockaddr *addr, size_t len) {
180   return (bind(socket, addr, len));}
181 inline int P_connect(int socket, struct sockaddr *addr, size_t len) {
182   return (connect(socket, addr, len));}
183 inline struct hostent * P_gethostbyname (const char *NAME) {
184   return (gethostbyname(NAME));}
185 /* inline int P_gethostname(char *name, size_t size) {
186    return (gethostname(name, size));} */
187 /* inline int P_getrusage(int i, struct rusage *ru) { 
188    return (getrusage(i, ru));} */
189 inline struct servent * P_getservbyname (const char *NAME, const char *PROTO) {
190   return (getservbyname(NAME, PROTO));}
191 inline int P_getsockname (int SOCKET, struct sockaddr *ADDR, size_t *LENGTH_PTR) {
192   return (getsockname(SOCKET, ADDR, LENGTH_PTR));}
193 inline int P_getsockopt(int s, int level, int optname, void *optval, 
194                         unsigned int *optlen) {
195    return getsockopt(s, level, optname, optval, 
196                      static_cast<socklen_t*>(optlen));
197 }
198 inline int P_setsockopt(int s, int level, int optname, void *optval, int optlen) {
199    return setsockopt(s, level, optname, (const char*)optval, optlen);
200 }
201
202 /* inline int P_gettimeofday (struct timeval *TP, struct timezone *TZP) {
203   return (gettimeofday(TP, TZP));} */
204 inline int P_listen (int socket, unsigned int n) { return (listen(socket, n));}
205 inline caddr_t P_mmap(caddr_t addr, size_t len, int prot, int flags,
206                       int fd, off_t off) {
207   return (static_cast<caddr_t>(mmap(addr, len, prot, flags, fd, off)));}
208 inline int P_munmap(caddr_t addr, int i) { return (munmap(addr, i));}
209 inline int P_socket (int NAMESPACE, int STYLE, int PROTOCOL) {
210   return (socket(NAMESPACE, STYLE, PROTOCOL));}
211 inline int P_socketpair(int namesp, int style, int protocol, int filedes[2]) {
212   return (socketpair(namesp, style, protocol, filedes));}
213 inline int P_pipe(int fds[2]) { return (pipe(fds)); }
214 inline int P_strcasecmp(const char *s1, const char *s2) {
215   return (strcasecmp(s1, s2));}
216 inline int P_strncasecmp (const char *S1, const char *S2, size_t N) {
217   return (strncasecmp(S1, S2,N));}
218 inline void P_endservent(void) { endservent(); }
219 inline int P_getpagesize() { return getpagesize(); }
220 inline int P_recv(int s, void *buf, size_t len, int flags) {
221    return (recv(s, buf, len, flags));
222 }
223
224 /* Ugly */
225
226 inline int P_ptrace(int req, pid_t pid, int addr, int data, int /*word_len*/) {
227   return (ptrace(req, pid, addr, data));}
228
229 inline int P_select(int wid, fd_set *rd, fd_set *wr, fd_set *ex,
230                     struct timeval *tm) {
231   return (select(wid, rd, wr, ex, tm));}
232
233 inline int P_rexec(char **ahost, u_short inport, char *user,
234                    char *passwd, char *cmd, int *fd2p) {
235   return (rexec(ahost, inport, user, passwd, cmd, fd2p));}
236
237 #if defined(__GNUC__)
238 #define DMGL_PARAMS      (1 << 0)       /* Include function args */
239 #define DMGL_ANSI        (1 << 1)       /* Include const, volatile, etc */
240
241 extern "C" char *cplus_demangle(char *, int);
242
243 /* Hack to allow nativeDemanglerBrokenness() to compile under gcc. */
244 #define DEMANGLE_ESPACE -1
245 #define DEMANGLE_ENAME  1
246
247 #else
248
249 #include <demangle.h>
250
251 #endif
252
253 inline char * nativeDemanglerBrokenness( int (*P_native_demangle)(const char *, char *, size_t),
254                                         char * symbol ) {
255         int length = 1024;
256         char * demangled = NULL;
257
258         /* Solaris native compiler adds "$X*." prefix to static variables compiled with
259            debuggur option. The native demangler does not handle this prefix for now.
260            So we strip the prefix. We look for the first occurance of period is the string. */
261
262         char *stripsymbol = symbol;
263         char *prefix1 = strstr (stripsymbol, "$X"); 
264         if (prefix1 == stripsymbol ) {
265             char *prefix2 = strchr(stripsymbol, '.');
266             if (prefix2) {
267                 prefix2++;
268                 stripsymbol = prefix2 ;
269             }
270         }
271
272         while( true ) {
273                 demangled = (char *)malloc( length * sizeof( char ) );
274                 if( demangled == NULL ) { return NULL; }
275                 
276                 int result = (* P_native_demangle)( stripsymbol, demangled, length );
277
278                 switch( result ) {
279                         case 0:
280                                 if (!strcmp(demangled,symbol)) {
281                                    free(demangled);
282                                    demangled = NULL;
283                                 }
284                                 return demangled;
285                         case DEMANGLE_ENAME:
286                                 return NULL;
287                         case DEMANGLE_ESPACE:
288                                 break;
289                         default:
290                                 assert( 0 );
291                         } /* end result switch */
292
293                 length += 1024;
294                 free( demangled );
295                 } /* end sizing loop */
296         } /* end nativeCompilerBrokenness() */
297
298 extern void dedemangle( char * demangled, char * dedemangled );
299 inline char * P_cplus_demangle( const char *symbol, bool nativeCompiler,
300                                         bool includeTypes = false ) {
301         char * demangled = NULL;
302
303 #if defined( __GNUC__ )
304   /* If the native demangler exists, try to demangled with it.
305      Otherwise, use the GNU demangler. */
306   if( ! nativeCompiler || P_native_demangle == NULL ) {
307     /* If we've been compiled with GNU and we're
308        demangling a GNU name, use cplus_demangle(). */
309     demangled = cplus_demangle( const_cast<char *>( symbol ), 
310                                     includeTypes ? DMGL_PARAMS|DMGL_ANSI  : 0 );
311     if( demangled == NULL ) { return NULL; }
312     } /* end if there's no native demangler */
313   else {
314     /* Use the native demangler. */
315     demangled = nativeDemanglerBrokenness( P_native_demangle, const_cast< char * >( symbol ) );
316
317     if( demangled == NULL ) { return NULL; }
318     } /* end if we're using the native demangler. */
319
320 #else 
321
322   /* We were compiled with the native compiler, so use its demangler. */
323   demangled = nativeDemanglerBrokenness( cplus_demangle, (char *)symbol );
324
325   if( demangled == NULL ) { return NULL; }  
326
327 #endif
328
329   if( ! includeTypes ) {
330         /* de-demangling never increases the length */
331         char * dedemangled = strdup( demangled );
332         assert( dedemangled != NULL );
333         dedemangle( demangled, dedemangled );
334         assert( dedemangled != NULL );
335
336         free( demangled );
337         return dedemangled;  
338         }
339
340   return demangled;
341   } /* end P_cplus_demangle() */
342
343 inline void   P_xdr_destroy(XDR *x) { xdr_destroy(x);}
344 inline bool_t P_xdr_u_char(XDR *x, u_char *uc) { return (xdr_u_char(x, uc));}
345 inline bool_t P_xdr_int(XDR *x, int *i) { return (xdr_int(x, i));}
346 inline bool_t P_xdr_double(XDR *x, double *d) {
347   return (xdr_double(x, d));}
348 inline bool_t P_xdr_u_int(XDR *x, u_int *u){
349   return (xdr_u_int(x, u));}
350 inline bool_t P_xdr_float(XDR *x, float *f) {
351   return (xdr_float(x, f));}
352 inline bool_t P_xdr_char(XDR *x, char *c) {
353   return (xdr_char(x, c));}
354 inline bool_t P_xdr_string(XDR *x, char **h, const u_int maxsize) {
355   return (xdr_string(x, h, maxsize));}
356
357 inline void P_xdrrec_create(XDR *x, const u_int send_sz, const u_int rec_sz,
358                             const caddr_t handle, 
359                             xdr_rd_func read_r, xdr_wr_func write_f) {
360 #if !defined(__GNUC__)
361   xdrrec_create(x, send_sz, rec_sz, handle,
362         read_r, write_f);
363 #else
364   xdrrec_create(x, send_sz, rec_sz, handle, read_r, write_f);
365 #endif
366 }
367 inline bool_t P_xdrrec_endofrecord(XDR *x, int now) { 
368   return (xdrrec_endofrecord(x, now));}
369 inline bool_t P_xdrrec_skiprecord(XDR *x) { return (xdrrec_skiprecord(x));}
370 inline bool_t P_xdrrec_eof(XDR *x) { return (xdrrec_eof(x)); }
371 inline int P_mkdir(const char *pathname, mode_t mode) {
372         return mkdir(pathname, mode);
373 }
374 inline int P_unlink(const char *pathname) {
375         return unlink(pathname);
376 }
377 #endif