source: trunk/base/src/pextlib1.0/tracelib.c @ 29369

Last change on this file since 29369 was 29369, checked in by epimenov@…, 13 years ago

Port trace: proper cleanup of depends var

File size: 11.5 KB
Line 
1/*
2 * tracelib.c
3 * $Id$
4 *
5 * Copyright (c) 2007 Eugene Pimenov (GSoC), MacPorts team
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 *    notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 *    notice, this list of conditions and the following disclaimer in the
15 *    documentation and/or other materials provided with the distribution.
16 * 3. Neither the name of Darwinports Team nor the names of its contributors
17 *    may be used to endorse or promote products derived from this software
18 *    without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
24 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include <config.h>
34#include <string.h>
35#include <sys/time.h>
36#include <sys/resource.h>
37#include <unistd.h>
38#include <stdio.h>
39#include <stdlib.h>
40#include <sys/socket.h>
41#include <sys/types.h>
42#include <sys/select.h>
43#include <sys/un.h>
44#include <stdarg.h>
45#include <errno.h>
46#include <pthread.h>
47#include "tracelib.h"
48
49static char * name;
50static char * sandbox;
51static char * filemap, * filemap_end;
52static char * depends; 
53static int sock=-1;
54static int enable_fence=0;
55static Tcl_Interp * interp;
56static pthread_mutex_t sock_mutex=PTHREAD_MUTEX_INITIALIZER;
57static int cleanuping=0;
58static char * sdk=
59#ifdef TRACE_SDK
60        /*"MacOSX10.4u.sdk"*/
61        TRACE_SDK
62#else
63        0
64#endif
65;
66
67static void send_file_map(int sock);
68static void dep_check(int sock, const char * path);
69static void sandbox_violation(int sock, const char * path);
70static void ui_warn(const char * format, ...);
71static void ui_info(const char * format, ...);
72
73#define MAX_SOCKETS ((FD_SETSIZE)-1)
74
75static int TracelibSetNameCmd(Tcl_Interp * interp, int objc, Tcl_Obj *CONST objv[])
76{
77        if (objc != 3)
78        {
79                Tcl_WrongNumArgs(interp, 2, objv, "number of arguments should be exactly 3");
80                return TCL_ERROR;
81        }
82       
83        name=strdup(Tcl_GetString(objv[2]));
84       
85        return TCL_OK;
86}
87
88/*
89 * Save sandbox path into memory and prepare it for checks.
90 * For now it just change : to \0, and add last \0
91 * Input:
92 *  /dev/null:/dev/tty:/tmp
93 * In variable;
94 * /dev/null\0/dev/tty\0/tmp\0\0
95 */
96static int TracelibSetSandboxCmd(Tcl_Interp * interp, int objc, Tcl_Obj *CONST objv[])
97{
98        int len;
99        char * t;
100       
101        if (objc != 3)
102        {
103                Tcl_WrongNumArgs(interp, 2, objv, "number of arguments should be exactly 3");
104                return TCL_ERROR;
105        }
106       
107        len=strlen(Tcl_GetString(objv[2]))+2;
108        sandbox=(char*)malloc(len);
109        memset(sandbox, 0, len);
110        strcpy(sandbox, Tcl_GetString(objv[2]));
111        for(t=sandbox;(t=strchr(t+1, ':'));)
112        {
113                /* : -> \0 */
114                if(t[-1]!='\\')
115                        *t=0;
116                else
117                        /* \: -> : */
118                        /* TODO \\: -> \: */
119                        memmove(t-1, t, strlen(t));
120        }
121       
122        return TCL_OK;
123}
124
125/*
126 * receive line from socket, parse it and send answer
127 */
128static char process_line(int sock)
129{
130        char * t, buf[1024]={0}, *f;
131        int len;
132       
133        if((len=recv(sock, buf, sizeof(buf), 0))==-1)
134                return 0;
135        if(!len)
136                return 0;
137        buf[len]=0;
138        /* sometimes two messages come in one recv.. I ain't caring about it now, but it can be a problem */
139        for(t=buf;*t&&t-buf<(int)sizeof(buf);t=f+strlen(f)+1)
140        {
141                f=strchr(t, '\t');
142                if(!f)
143                {
144                        ui_warn("malformed command %s", t);
145                        break;
146                }
147                *f++=0;
148                if(!strcmp(t, "filemap"))
149                {
150                        send_file_map(sock);
151                }else if(!strcmp(t, "sandbox_violation"))
152                {
153                        sandbox_violation(sock, f);
154                }else if(!strcmp(t, "dep_check"))
155                {
156                        dep_check(sock, f);
157                }else if(!strcmp(t, "execve"))
158                {
159                        /* ====================== */
160                        /* = TODO: do something = */
161                        /* ====================== */
162                }else
163                {
164                        ui_warn("unknown command %s (%s)", t, f);
165                }
166        }
167        return 1;
168}
169
170static void send_file_map(int sock)
171{
172        if(!filemap)
173        {
174                char * t, * _;
175               
176                filemap=(char*)malloc(1024);
177                t=filemap;
178               
179                #define append_allow(path, resolution) do{strcpy(t, path); t+=strlen(t)+1; *t++=resolution; *t++=0;}while(0);
180                if(enable_fence)
181                {
182                        for(_=sandbox; *_; _+=strlen(_)+1)
183                                append_allow(_, 0);
184                       
185                        append_allow("/bin", 0);
186                        append_allow("/sbin", 0);
187                        append_allow("/dev", 0)
188                        append_allow(Tcl_GetVar(interp, "macports::prefix", TCL_GLOBAL_ONLY), 2);
189                        /* If there is no SDK we will allow everything in /usr /System/Library etc, else add binaries to allow, and redirect root to SDK. */
190                        if(sdk&&*sdk)
191                        {
192                                char buf[260]="/Developer/SDKs/";
193                                strcat(buf, sdk);
194                       
195                                append_allow("/usr/bin", 0);
196                                append_allow("/usr/sbin", 0);
197                                append_allow("/usr/libexec/gcc", 0);
198                                append_allow("/System/Library/Perl", 0);
199                                append_allow("/usr/X11R6/bin", 0);
200                                append_allow("/", 1);
201                                strcpy(t-1, buf);
202                                t+=strlen(t)+1;
203                        }else
204                        {
205                                append_allow("/usr", 0);
206                                append_allow("/System/Library", 0);
207                                append_allow("/Library", 0);
208                                append_allow("/Developer/Headers", 0);
209                        }
210                }else
211                        append_allow("/", 0);
212                filemap_end=t;
213                #undef append_allow
214        }
215       
216        {
217                size_t s=filemap_end-filemap;
218                send(sock, &s, sizeof(s), 0);
219                send(sock, filemap, s, 0);
220        }
221}
222
223static void sandbox_violation(int sock UNUSED, const char * path)
224{
225        Tcl_SetVar(interp, "path", path, 0);
226        Tcl_Eval(interp, "slave_add_sandbox_violation $path");
227        Tcl_UnsetVar(interp, "path", 0);
228}
229
230static void dep_check(int sock, const char * path)
231{
232        char * port=0;
233        size_t len=1;
234        char resolution; 
235       
236        /* If there aren't deps then allow anything. (Useful for extract) */
237        if(!depends)
238                resolution='+';
239        else
240        {
241                resolution='!';
242               
243                Tcl_SetVar(interp, "path", path, 0);
244                Tcl_Eval(interp, "registry::file_registered $path");
245                port=strdup(Tcl_GetStringResult(interp));
246                Tcl_UnsetVar(interp, "path", 0);
247       
248                if(*port!='0'||port[1])
249                {
250                        char * t;
251               
252                        t=depends;
253                        for(;*t;t+=strlen(t)+1)
254                        {
255                                if(!strcmp(t, port))
256                                {
257                                        resolution='+';
258                                        break;
259                                }
260                        }
261                }
262        }
263       
264        if(resolution!='+')
265                ui_info("trace: access denied to %s (%s)", path, port);
266
267        if(port)
268                free(port);
269       
270        if(send(sock, &len, sizeof(len), 0)==-1)
271                ui_warn("tracelib send failed");
272        if(send(sock, &resolution, 1, 0)==-1)
273                ui_warn("tracelib send failed");
274}
275
276static void ui_msg(const char * severity, const char * format, va_list va)
277{
278        char buf[1024], tclcmd[32];
279       
280        vsprintf(buf, format, va);
281       
282        sprintf(tclcmd, "ui_%s $warn", severity);
283       
284        Tcl_SetVar(interp, "warn", buf, 0);
285       
286        Tcl_Eval(interp, tclcmd);
287        Tcl_UnsetVar(interp, "warn", 0);
288       
289}
290
291static void ui_warn(const char * format, ...)
292{
293        va_list va;
294       
295        va_start(va, format);
296                ui_msg("warn", format, va);
297        va_end(va);
298}
299
300static void ui_info(const char * format, ...)
301{
302        va_list va;
303       
304        va_start(va, format);
305                ui_msg("msg", format, va);
306        va_end(va);
307}
308
309static int TracelibRunCmd(Tcl_Interp * in)
310{
311        struct sockaddr_un sun;
312        fd_set fdr;
313        int i;
314        int max_fd, max_used, socks[MAX_SOCKETS];
315        struct rlimit rl;
316       
317        pthread_mutex_lock(&sock_mutex);
318        if(cleanuping)
319        {
320                pthread_mutex_unlock(&sock_mutex);
321                return 0;
322        }
323        sock=socket(AF_UNIX, SOCK_STREAM, 0);
324        pthread_mutex_unlock(&sock_mutex);
325       
326        interp=in;
327       
328        rl.rlim_cur=rl.rlim_max=RLIM_INFINITY;
329        if(setrlimit(RLIMIT_NOFILE, &rl)==-1)
330        {
331                ui_warn("setrlimit failed (%d)", errno);
332        }
333
334       
335        sun.sun_family=AF_UNIX;
336        strcpy(sun.sun_path, name);
337        if(bind(sock, (struct sockaddr*)&sun, sizeof(sun))==-1)
338        {
339                Tcl_SetResult(interp, "Cannot bind socket", TCL_STATIC);
340                return TCL_ERROR;
341        }
342       
343        listen(sock, 5);
344        max_used=0;
345        max_fd=sock;
346       
347        for(;sock!=-1&&!cleanuping;)
348        {
349                FD_ZERO(&fdr);
350                FD_SET(sock, &fdr);
351                for(i=0;i<max_used;++i)
352                        FD_SET(socks[i], &fdr);
353                               
354                if(select(max_fd+1, &fdr, 0, 0, 0)<1)
355                {
356                        continue;
357                }
358                if(sock==-1)
359                {
360                        break;
361                }
362                if(FD_ISSET(sock, &fdr))
363                {
364                        int s;
365                        s=accept(sock, 0, 0);
366                       
367                        if(s==-1)
368                        {
369                                if(cleanuping)
370                                        break;
371                                else
372                                        ui_warn("tracelib: accept return -1 (errno: %d)", errno);
373                                /* failed sometimes and i dunno why*/
374                                continue;
375                        }
376                        /* Temporary solution, it's better to regenerate this variable in each iteration, because when closing socket we'll get it too high */                         
377                        if(s>max_fd)
378                                max_fd=s;
379                        for(i=0;i<max_used;++i)
380                                if(!socks[i])
381                                {
382                                        socks[i]=s;
383                                        break;
384                                }
385                        if(i==max_used)
386                        {
387                                if(max_used==MAX_SOCKETS-1)
388                                {
389                                        ui_warn("There is no place to store socket");
390                                        close(s);
391                                }
392                                else
393                                        socks[max_used++]=s;
394                        }
395                }
396               
397                for(i=0;i<max_used;++i)
398                {
399                        if(!socks[i])
400                                continue;
401                        if(FD_ISSET(socks[i], &fdr))
402                        {
403                                if(!process_line(socks[i]))
404                                {
405                                        close(socks[i]);
406                                        socks[i]=0;
407                                        continue;
408                                }
409                        }
410                }
411        }
412       
413        for(i=0;i<max_used;++i)
414        {
415                if(socks[i])
416                {
417                        close(socks[i]);
418                        socks[i]=0;
419                }
420        }
421       
422        return TCL_OK;
423}
424
425static int TracelibCleanCmd(Tcl_Interp * interp UNUSED)
426{
427        #define safe_free(x) do{free(x); x=0;}while(0);
428        cleanuping=1;
429        pthread_mutex_lock(&sock_mutex);
430        if(sock!=-1)
431        {
432                /* shutdown(sock, SHUT_RDWR);*/
433                close(sock);
434                sock=-1;
435        }
436        pthread_mutex_unlock(&sock_mutex);
437        if(name)
438        {
439                unlink(name);
440                safe_free(name);
441        }
442        if(filemap)
443                safe_free(filemap);
444        if(depends)
445                safe_free(depends);
446        enable_fence=0;
447        #undef safe_free
448        cleanuping=0;
449        return TCL_OK;
450}
451
452static int TracelibCloseSocketCmd(Tcl_Interp * interp UNUSED)
453{
454        cleanuping=1;
455        pthread_mutex_lock(&sock_mutex);
456        if(sock!=-1)
457        {
458                /*shutdown(sock, SHUT_RDWR);*/
459                close(sock);
460                sock=-1;
461        }
462        pthread_mutex_unlock(&sock_mutex);
463        return TCL_OK;
464}
465
466static int TracelibSetDeps(Tcl_Interp * interp UNUSED, int objc, Tcl_Obj* CONST objv[])
467{
468        char * t, * d;
469        size_t l;
470        if(objc!=3)
471        {
472                Tcl_WrongNumArgs(interp, 2, objv, "number of arguments should be exactly 3");
473                return TCL_ERROR;
474        }
475       
476        d=Tcl_GetString(objv[2]);
477        l=strlen(d);
478        depends=malloc(l+2);
479        depends[l+1]=0;
480        strcpy(depends, d);
481        for(t=depends;*t;++t)
482                if(*t==' ')
483                        *t++=0;
484       
485        return TCL_OK;
486}
487
488static int TracelibEnableFence(Tcl_Interp * interp UNUSED)
489{
490        enable_fence=1;
491        if(filemap)
492                free(filemap);
493        filemap=0;
494        return TCL_OK;
495}
496
497int TracelibCmd(ClientData clientData UNUSED, Tcl_Interp* interp, int objc, Tcl_Obj* CONST objv[])
498{
499        int result=TCL_OK;
500        static const char * options[]={"setname", "run", "clean", "setsandbox", "closesocket", "setdeps", "enablefence", 0};
501        typedef enum 
502        {
503                kSetName,
504                kRun,
505                kClean,
506                kSetSandbox,
507                kCloseSocket,
508                kSetDeps,
509                kEnableFence
510        } EOptions;
511        EOptions current_option;
512       
513        /* There is no args for commands now. */
514        if (objc <2)
515        {
516                Tcl_WrongNumArgs(interp, 1, objv, "option");
517                return TCL_ERROR;
518        }
519       
520        result=Tcl_GetIndexFromObj(interp, objv[1], options, "option", 0, (int*)&current_option);
521        if(result==TCL_OK)
522        {
523                switch(current_option)
524                {
525                case kSetName:
526                        result=TracelibSetNameCmd(interp, objc, objv);
527                        break;
528                case kRun:
529                        result=TracelibRunCmd(interp);
530                        break;
531                case kClean:
532                        result=TracelibCleanCmd(interp);
533                        break;
534                case kCloseSocket:
535                        result=TracelibCloseSocketCmd(interp);
536                        break;
537                case kSetSandbox:
538                        result=TracelibSetSandboxCmd(interp, objc, objv);
539                        break;
540                case kSetDeps:
541                        result=TracelibSetDeps(interp, objc, objv);
542                        break;
543                case kEnableFence:
544                        result=TracelibEnableFence(interp);
545                        break;
546                }
547        }
548       
549        return result;
550}
Note: See TracBrowser for help on using the repository browser.