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

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

tracelib: 0 -> *unknown* in access denied message; creation/deletion/modification -> activity

  • Property svn:keywords set to Id
File size: 11.6 KB
Line 
1/*
2 * tracelib.c
3 * $Id: tracelib.c 29696 2007-10-05 20:25:48Z epimenov@macports.org $
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                }else if(*port=='0'&&!port[1])
262                        strcpy(port, "*unknown*");
263        }
264       
265        if(resolution!='+')
266                ui_info("trace: access denied to %s (%s)", path, port);
267
268        if(port)
269                free(port);
270       
271        if(send(sock, &len, sizeof(len), 0)==-1)
272                ui_warn("tracelib send failed");
273        if(send(sock, &resolution, 1, 0)==-1)
274                ui_warn("tracelib send failed");
275}
276
277static void ui_msg(const char * severity, const char * format, va_list va)
278{
279        char buf[1024], tclcmd[32];
280       
281        vsprintf(buf, format, va);
282       
283        sprintf(tclcmd, "ui_%s $warn", severity);
284       
285        Tcl_SetVar(interp, "warn", buf, 0);
286       
287        Tcl_Eval(interp, tclcmd);
288        Tcl_UnsetVar(interp, "warn", 0);
289       
290}
291
292static void ui_warn(const char * format, ...)
293{
294        va_list va;
295       
296        va_start(va, format);
297                ui_msg("warn", format, va);
298        va_end(va);
299}
300
301static void ui_info(const char * format, ...)
302{
303        va_list va;
304       
305        va_start(va, format);
306                ui_msg("msg", format, va);
307        va_end(va);
308}
309
310static int TracelibRunCmd(Tcl_Interp * in)
311{
312        struct sockaddr_un sun;
313        fd_set fdr;
314        int i;
315        int max_fd, max_used, socks[MAX_SOCKETS];
316        struct rlimit rl;
317       
318        pthread_mutex_lock(&sock_mutex);
319        if(cleanuping)
320        {
321                pthread_mutex_unlock(&sock_mutex);
322                return 0;
323        }
324        sock=socket(AF_UNIX, SOCK_STREAM, 0);
325        pthread_mutex_unlock(&sock_mutex);
326       
327        interp=in;
328       
329        rl.rlim_cur=rl.rlim_max=RLIM_INFINITY;
330        if(setrlimit(RLIMIT_NOFILE, &rl)==-1)
331        {
332                ui_warn("setrlimit failed (%d)", errno);
333        }
334
335       
336        sun.sun_family=AF_UNIX;
337        strcpy(sun.sun_path, name);
338        if(bind(sock, (struct sockaddr*)&sun, sizeof(sun))==-1)
339        {
340                Tcl_SetResult(interp, "Cannot bind socket", TCL_STATIC);
341                return TCL_ERROR;
342        }
343       
344        listen(sock, 5);
345        max_used=0;
346        max_fd=sock;
347       
348        for(;sock!=-1&&!cleanuping;)
349        {
350                FD_ZERO(&fdr);
351                FD_SET(sock, &fdr);
352                for(i=0;i<max_used;++i)
353                        FD_SET(socks[i], &fdr);
354                               
355                if(select(max_fd+1, &fdr, 0, 0, 0)<1)
356                {
357                        continue;
358                }
359                if(sock==-1)
360                {
361                        break;
362                }
363                if(FD_ISSET(sock, &fdr))
364                {
365                        int s;
366                        s=accept(sock, 0, 0);
367                       
368                        if(s==-1)
369                        {
370                                if(cleanuping)
371                                        break;
372                                else
373                                        ui_warn("tracelib: accept return -1 (errno: %d)", errno);
374                                /* failed sometimes and i dunno why*/
375                                continue;
376                        }
377                        /* Temporary solution, it's better to regenerate this variable in each iteration, because when closing socket we'll get it too high */                         
378                        if(s>max_fd)
379                                max_fd=s;
380                        for(i=0;i<max_used;++i)
381                                if(!socks[i])
382                                {
383                                        socks[i]=s;
384                                        break;
385                                }
386                        if(i==max_used)
387                        {
388                                if(max_used==MAX_SOCKETS-1)
389                                {
390                                        ui_warn("There is no place to store socket");
391                                        close(s);
392                                }
393                                else
394                                        socks[max_used++]=s;
395                        }
396                }
397               
398                for(i=0;i<max_used;++i)
399                {
400                        if(!socks[i])
401                                continue;
402                        if(FD_ISSET(socks[i], &fdr))
403                        {
404                                if(!process_line(socks[i]))
405                                {
406                                        close(socks[i]);
407                                        socks[i]=0;
408                                        continue;
409                                }
410                        }
411                }
412        }
413       
414        for(i=0;i<max_used;++i)
415        {
416                if(socks[i])
417                {
418                        close(socks[i]);
419                        socks[i]=0;
420                }
421        }
422       
423        return TCL_OK;
424}
425
426static int TracelibCleanCmd(Tcl_Interp * interp UNUSED)
427{
428        #define safe_free(x) do{free(x); x=0;}while(0);
429        cleanuping=1;
430        pthread_mutex_lock(&sock_mutex);
431        if(sock!=-1)
432        {
433                /* shutdown(sock, SHUT_RDWR);*/
434                close(sock);
435                sock=-1;
436        }
437        pthread_mutex_unlock(&sock_mutex);
438        if(name)
439        {
440                unlink(name);
441                safe_free(name);
442        }
443        if(filemap)
444                safe_free(filemap);
445        if(depends)
446                safe_free(depends);
447        enable_fence=0;
448        #undef safe_free
449        cleanuping=0;
450        return TCL_OK;
451}
452
453static int TracelibCloseSocketCmd(Tcl_Interp * interp UNUSED)
454{
455        cleanuping=1;
456        pthread_mutex_lock(&sock_mutex);
457        if(sock!=-1)
458        {
459                /*shutdown(sock, SHUT_RDWR);*/
460                close(sock);
461                sock=-1;
462        }
463        pthread_mutex_unlock(&sock_mutex);
464        return TCL_OK;
465}
466
467static int TracelibSetDeps(Tcl_Interp * interp UNUSED, int objc, Tcl_Obj* CONST objv[])
468{
469        char * t, * d;
470        size_t l;
471        if(objc!=3)
472        {
473                Tcl_WrongNumArgs(interp, 2, objv, "number of arguments should be exactly 3");
474                return TCL_ERROR;
475        }
476       
477        d=Tcl_GetString(objv[2]);
478        l=strlen(d);
479        depends=malloc(l+2);
480        depends[l+1]=0;
481        strcpy(depends, d);
482        for(t=depends;*t;++t)
483                if(*t==' ')
484                        *t++=0;
485       
486        return TCL_OK;
487}
488
489static int TracelibEnableFence(Tcl_Interp * interp UNUSED)
490{
491        enable_fence=1;
492        if(filemap)
493                free(filemap);
494        filemap=0;
495        return TCL_OK;
496}
497
498int TracelibCmd(ClientData clientData UNUSED, Tcl_Interp* interp, int objc, Tcl_Obj* CONST objv[])
499{
500        int result=TCL_OK;
501        static const char * options[]={"setname", "run", "clean", "setsandbox", "closesocket", "setdeps", "enablefence", 0};
502        typedef enum 
503        {
504                kSetName,
505                kRun,
506                kClean,
507                kSetSandbox,
508                kCloseSocket,
509                kSetDeps,
510                kEnableFence
511        } EOptions;
512        EOptions current_option;
513       
514        /* There is no args for commands now. */
515        if (objc <2)
516        {
517                Tcl_WrongNumArgs(interp, 1, objv, "option");
518                return TCL_ERROR;
519        }
520       
521        result=Tcl_GetIndexFromObj(interp, objv[1], options, "option", 0, (int*)&current_option);
522        if(result==TCL_OK)
523        {
524                switch(current_option)
525                {
526                case kSetName:
527                        result=TracelibSetNameCmd(interp, objc, objv);
528                        break;
529                case kRun:
530                        result=TracelibRunCmd(interp);
531                        break;
532                case kClean:
533                        result=TracelibCleanCmd(interp);
534                        break;
535                case kCloseSocket:
536                        result=TracelibCloseSocketCmd(interp);
537                        break;
538                case kSetSandbox:
539                        result=TracelibSetSandboxCmd(interp, objc, objv);
540                        break;
541                case kSetDeps:
542                        result=TracelibSetDeps(interp, objc, objv);
543                        break;
544                case kEnableFence:
545                        result=TracelibEnableFence(interp);
546                        break;
547                }
548        }
549       
550        return result;
551}
Note: See TracBrowser for help on using the repository browser.