add a small wrapper lib for call modified versions of open/open64/fopen/fopen64/socke...
[vuplus_dvbapp] / tools / libopen.c
1 #define _GNU_SOURCE
2 #include <sys/types.h>
3 #include <sys/stat.h>
4 #include <sys/socket.h>
5 #include <fcntl.h>
6 #include <dlfcn.h>
7 #include <stdio.h>
8 #include <stdlib.h>
9
10 #undef DEBUG
11
12 int open64(const char *pathname, int flags, ...)
13 {
14         static int (*libc_open64) (const char* pathname, int flags, ...);
15         int fd=-1;
16         if (!libc_open64)
17         {
18                 void *handle;
19                 char *error;
20                 handle = dlopen("/lib/libc.so.6", RTLD_LAZY);
21                 if (!handle)
22                 {
23                         fputs(dlerror(), stderr);
24                         exit(1);
25                 }
26                 libc_open64 = dlsym(handle, "open64");
27                 if ((error = dlerror()) != NULL) {
28                         fprintf(stderr, "%s\n", error);
29                         exit(1);
30                 }
31         }
32         fd = libc_open64(pathname, flags);
33         if (fd >= 0)
34         {
35                 int fd_flags = fcntl(fd, F_GETFD, 0);
36                 if (fd_flags >= 0)
37                 {
38                         fd_flags |= FD_CLOEXEC;
39                         fcntl(fd, F_SETFD, fd_flags);
40                 }
41 #ifdef DEBUG
42                 fprintf(stdout, "open64 %s, flags %d returned fd %d\n", pathname, flags, fd);
43 #endif
44         }
45         return fd;
46 }
47
48 int open(const char *pathname, int flags, ...)
49 {
50         static int (*libc_open) (const char* pathname, int flags, ...);
51         int fd=-1;
52         if (!libc_open)
53         {
54                 void *handle;
55                 char *error;
56                 handle = dlopen("/lib/libc.so.6", RTLD_LAZY);
57                 if (!handle)
58                 {
59                         fputs(dlerror(), stderr);
60                         exit(1);
61                 }
62                 libc_open = dlsym(handle, "open");
63                 if ((error = dlerror()) != NULL) {
64                         fprintf(stderr, "%s\n", error);
65                         exit(1);
66                 }
67         }
68         fd = libc_open(pathname, flags);
69         if (fd >= 0)
70         {
71                 int fd_flags = fcntl(fd, F_GETFD, 0);
72                 if (fd_flags >= 0)
73                 {
74                         fd_flags |= FD_CLOEXEC;
75                         fcntl(fd, F_SETFD, fd_flags);
76                 }
77 #ifdef DEBUG
78                 fprintf(stdout, "open %s, flags %d returned fd %d\n", pathname, flags, fd);
79 #endif
80         }
81         return fd;
82 }
83
84 FILE *fopen64(const char *pathname, const char *mode)
85 {
86         static FILE *(*libc_fopen64) (const char* pathname, const char *mode);
87         FILE *f=0;
88         if (!libc_fopen64)
89         {
90                 void *handle;
91                 char *error;
92                 handle = dlopen("/lib/libc.so.6", RTLD_LAZY);
93                 if (!handle)
94                 {
95                         fputs(dlerror(), stderr);
96                         exit(1);
97                 }
98                 libc_fopen64 = dlsym(handle, "fopen64");
99                 if ((error = dlerror()) != NULL) {
100                         fprintf(stderr, "%s\n", error);
101                         exit(1);
102                 }
103         }
104         f = libc_fopen64(pathname, mode);
105         if (f)
106         {
107                 int fd = fileno(f);
108                 int fd_flags = fcntl(fd, F_GETFD, 0);
109                 if (fd_flags >= 0)
110                 {
111                         fd_flags |= FD_CLOEXEC;
112                         fcntl(fd, F_SETFD, fd_flags);
113                 }
114 #ifdef DEBUG
115                 fprintf(stdout, "fopen64 %s, mode %s returned FILE* %p fd %d\n", pathname, mode, f, fd);
116 #endif
117         }
118         return f;
119 }
120
121 FILE *fopen(const char *pathname, const char *mode)
122 {
123         static FILE *(*libc_fopen) (const char* pathname, const char *mode);
124         FILE *f=0;
125         if (!libc_fopen)
126         {
127                 void *handle;
128                 char *error;
129                 handle = dlopen("/lib/libc.so.6", RTLD_LAZY);
130                 if (!handle)
131                 {
132                         fputs(dlerror(), stderr);
133                         exit(1);
134                 }
135                 libc_fopen = dlsym(handle, "fopen");
136                 if ((error = dlerror()) != NULL) {
137                         fprintf(stderr, "%s\n", error);
138                         exit(1);
139                 }
140         }
141         f = libc_fopen(pathname, mode);
142         if (f)
143         {
144                 int fd = fileno(f);
145                 int fd_flags = fcntl(fd, F_GETFD, 0);
146                 if (fd_flags >= 0)
147                 {
148                         fd_flags |= FD_CLOEXEC;
149                         fcntl(fd, F_SETFD, fd_flags);
150                 }
151 #ifdef DEBUG
152                 fprintf(stdout, "fopen %s, mode %s returned FILE* %p fd %d\n", pathname, mode, f, fd);
153 #endif
154         }
155         return f;
156 }
157
158 int socket(int domain, int type, int protocol)
159 {
160         static int (*libc_socket) (int domain, int type, int protocol);
161         int fd=-1;
162         if (!libc_socket)
163         {
164                 void *handle;
165                 char *error;
166                 handle = dlopen("/lib/libc.so.6", RTLD_LAZY);
167                 if (!handle)
168                 {
169                         fputs(dlerror(), stderr);
170                         exit(1);
171                 }
172                 libc_socket = dlsym(handle, "socket");
173                 if ((error = dlerror()) != NULL) {
174                         fprintf(stderr, "%s\n", error);
175                         exit(1);
176                 }
177         }
178         fd = libc_socket(domain, type, protocol);
179         if (fd >= 0)
180         {
181                 int fd_flags = fcntl(fd, F_GETFD, 0);
182                 if (fd_flags >= 0)
183                 {
184                         fd_flags |= FD_CLOEXEC;
185                         fcntl(fd, F_SETFD, fd_flags);
186                 }
187 #ifdef DEBUG
188                 fprintf(stdout, "socket fd %d\n", fd);
189 #endif
190         }
191         return fd;
192 }
193
194 int pipe(int modus[2])
195 {
196         static int (*libc_pipe) (int modus[2]);
197         int ret=-1;
198         if (!libc_pipe)
199         {
200                 void *handle;
201                 char *error;
202                 handle = dlopen("/lib/libc.so.6", RTLD_LAZY);
203                 if (!handle)
204                 {
205                         fputs(dlerror(), stderr);
206                         exit(1);
207                 }
208                 libc_pipe = dlsym(handle, "pipe");
209                 if ((error = dlerror()) != NULL) {
210                         fprintf(stderr, "%s\n", error);
211                         exit(1);
212                 }
213         }
214         ret = libc_pipe(modus);
215         if (!ret)
216         {
217                 int fd_flags = fcntl(modus[0], F_GETFD, 0);
218                 if (fd_flags >= 0)
219                 {
220                         fd_flags |= FD_CLOEXEC;
221                         fcntl(modus[0], F_SETFD, fd_flags);
222                 }
223                 fd_flags = fcntl(modus[1], F_GETFD, 0);
224                 if (fd_flags >= 0)
225                 {
226                         fd_flags |= FD_CLOEXEC;
227                         fcntl(modus[1], F_SETFD, fd_flags);
228                 }
229 #ifdef DEBUG
230                 fprintf(stdout, "pipe fds[%d, %d]\n", modus[0], modus[1]);
231 #endif
232         }
233         return ret;
234 }
235