Changeset 26682


Ignore:
Timestamp:
Jul 3, 2007, 5:42:36 PM (13 years ago)
Author:
epimenov@…
Message:

Trace lib on unix sockets. No dep check for now.

Location:
trunk/base/src
Files:
2 added
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/base/src/darwintracelib1.0/darwintrace.c

    r19376 r26682  
    5858#include <sys/syscall.h>
    5959#include <errno.h>
     60#include <sys/socket.h>
     61#include <sys/un.h>
    6062
    6163#ifndef HAVE_STRLCPY
     
    120122 */
    121123inline int __darwintrace_strbeginswith(const char* str, const char* prefix);
    122 inline void __darwintrace_log_op(const char* op, const char* procname, const char* path, int fd);
     124inline void __darwintrace_log_op(const char* op, const char* path, int fd);
    123125void __darwintrace_copy_env() __attribute__((constructor));
    124126inline char* __darwintrace_alloc_env(const char* varName, const char* varValue);
     
    126128inline void __darwintrace_setup();
    127129inline void __darwintrace_cleanup_path(char *path);
     130static char * exchange_with_port(const char * buf, size_t len, int answer);
    128131
    129132#define START_FD 81
    130 static int __darwintrace_fd = -2;
     133static int __darwintrace_fd = -1;
    131134#define BUFFER_SIZE     1024
    132 #if DARWINTRACE_SHOW_PROCESS
    133 static char __darwintrace_progname[BUFFER_SIZE];
    134 static pid_t __darwintrace_pid = -1;
    135 #endif
    136 #if DARWINTRACE_SANDBOX
    137 static char** __darwintrace_sandbox_bounds = NULL;
    138 #endif
     135
     136/**
     137 * filemap: path\0whattodo\0path\0whattodo\0\0
     138 * path: begin of path (for example /opt)
     139 * whattodo:
     140 *   0     -- allow
     141 *   1PATH -- map
     142 *   2     -- ask for allow
     143**/
     144static char * filemap=0;
    139145
    140146/* copy of the global variables */
     
    142148static char* __env_dyld_force_flat_namespace;
    143149static char* __env_darwintrace_log;
    144 #if DARWINTRACE_SANDBOX
    145 static char* __env_darwintrace_sandbox_bounds;
    146 #endif
    147 
    148 #if __STDC_VERSION__==199901L
     150
     151#if __STDC_VERSION__>=199901L
    149152#if DARWINTRACE_DEBUG_OUTPUT
    150153#define dprintf(...) fprintf(stderr, __VA_ARGS__)
     
    159162#endif
    160163#endif
     164
     165/*
     166 * char wait_for_socket(int sock, char w)
     167 * Function used for read/write operation to socket...
     168 * Args:
     169 *  sock - socket
     170 *  w - what should socket do in next operation. 1 for write, 0 for read
     171 * Return value:
     172 *  1 - everything is ok, we can read/write to/from it
     173 *  0 - something's went wrong
     174 */
     175static int wait_for_socket(int sock, char w)
     176{
     177        struct timeval tv;
     178        fd_set fds;
     179       
     180        if(sock==-1)
     181                return 0;
     182       
     183        tv.tv_sec=10;
     184        tv.tv_usec=0;
     185        FD_ZERO(&fds);
     186        FD_SET(sock, &fds);
     187        if(select(sock+1, (w==0 ? &fds : 0), (w==1 ? &fds : 0), 0, &tv)<1)
     188                return 0;
     189        return FD_ISSET(sock, &fds)!=0;
     190}
     191
    161192
    162193/*
     
    196227                __env_darwintrace_log = NULL;
    197228        }
    198 #if DARWINTRACE_SANDBOX
    199         theValue = getenv("DARWINTRACE_SANDBOX_BOUNDS");
    200         if (theValue != NULL) {
    201                 __env_darwintrace_sandbox_bounds = strdup(theValue);
    202         } else {
    203                 __env_darwintrace_sandbox_bounds = NULL;
    204         }
    205 #endif
    206229}
    207230
     
    244267                        "DARWINTRACE_LOG",
    245268                        __env_darwintrace_log);
    246 #if DARWINTRACE_SANDBOX
    247         char* darwintrace_sandbox_bounds_ptr = 
    248                 __darwintrace_alloc_env(
    249                         "DARWINTRACE_SANDBOX_BOUNDS",
    250                         __env_darwintrace_sandbox_bounds);
    251 #endif
    252269
    253270        char* const * theEnvIter = envp;
     
    277294                        theValue = darwintrace_log_ptr;
    278295                        darwintrace_log_ptr = NULL;
    279 #if DARWINTRACE_SANDBOX
    280                 } else if (__darwintrace_strbeginswith(theValue, "DARWINTRACE_SANDBOX_BOUNDS=")) {
    281                         theValue = darwintrace_sandbox_bounds_ptr;
    282                         darwintrace_sandbox_bounds_ptr = NULL;
    283 #endif
    284296                }
    285297               
     
    300312                *theCopyIter++ = darwintrace_log_ptr;
    301313        }
    302 #if DARWINTRACE_SANDBOX
    303         if (darwintrace_sandbox_bounds_ptr) {
    304                 *theCopyIter++ = darwintrace_sandbox_bounds_ptr;
    305         }
    306 #endif
    307314
    308315        *theCopyIter = 0;
    309316       
    310317        return theCopy;
     318}
     319
     320static void ask_for_filemap()
     321{
     322        filemap=exchange_with_port("filemap\t", sizeof("filemap\t"), 1);
     323        if((int)filemap==-1)
     324                filemap=0;
    311325}
    312326
     
    314328#define open(x,y,z) syscall(SYS_open, (x), (y), (z))
    315329#define close(x) syscall(SYS_close, (x))
    316         if (__darwintrace_fd == -2) {
     330        if (__darwintrace_fd == -1) {
    317331                if (__env_darwintrace_log != NULL) {
    318332                        int olderrno = errno;
    319                         int fd = open(__env_darwintrace_log, O_CREAT | O_WRONLY | O_APPEND, DEFFILEMODE);
    320                         int newfd;
    321                         for(newfd = START_FD; newfd < START_FD + 21; newfd++) {
    322                                 if(-1 == write(newfd, "", 0) && errno == EBADF) {
    323                                         if(-1 != dup2(fd, newfd)) {
    324                                                 __darwintrace_fd = newfd;
    325                                         }
    326                                         close(fd);
    327                                         fcntl(__darwintrace_fd, F_SETFD, 1); /* close-on-exec */
    328                                         break;
    329                                 }
    330                         }
     333                        int sock=socket(AF_UNIX, SOCK_STREAM, 0);
     334                        struct sockaddr_un sun;
     335                        sun.sun_family=AF_UNIX;
     336                        strcpy(sun.sun_path, __env_darwintrace_log);
     337                        if(connect(sock, (struct sockaddr*)&sun, strlen(__env_darwintrace_log)+1+sizeof(sun.sun_family))!=-1)
     338                        {
     339                                dprintf("darwintrace: connect successful. socket %d\n", sock);
     340                                __darwintrace_fd=sock;
     341                                ask_for_filemap();
     342                        }else dprintf("connect failed %d :-(\n", errno);
    331343                        errno = olderrno;
    332344                }
    333345        }
    334 #if DARWINTRACE_SHOW_PROCESS
    335         if (__darwintrace_pid == -1) {
    336                 char** progname = _NSGetProgname();
    337                 __darwintrace_pid = getpid();
    338                 if (progname && *progname) {
    339                         strcpy(__darwintrace_progname, *progname);
    340                 }
    341         }
    342 #endif
    343 #if DARWINTRACE_SANDBOX
    344         if (__darwintrace_sandbox_bounds == NULL) {
    345                 if (__env_darwintrace_sandbox_bounds != NULL) {
    346                         /* copy the string */
    347                         char* copy = strdup(__env_darwintrace_sandbox_bounds);
    348                         if (copy != NULL) {
    349                                 int nbPaths = 1;
    350                                 int nbAllocatedPaths = 5;
    351                                 char** paths = (char**) malloc(sizeof(char*) * nbAllocatedPaths);
    352                                 char* crsr = copy;
    353                                 char** pathsCrsr = paths;
    354                                 /* first path */
    355                                 *pathsCrsr++ = crsr;
    356                                 /* parse the paths (modify the copy) */
    357                                 do {
    358                                         char theChar = *crsr;
    359                                         if (theChar == '\0') {
    360                                                 /* the end of the paths */
    361                                                 break;
    362                                         }
    363                                         if (theChar == ':') {
    364                                                 /* the end of this path */
    365                                                 *crsr = 0;
    366                                                 nbPaths++;
    367                                                 if (nbPaths == nbAllocatedPaths) {
    368                                                         nbAllocatedPaths += 5;
    369                                                         paths = (char**) realloc(paths, sizeof(char*) * nbAllocatedPaths);
    370                                                         /* reset the cursor in case paths pointer was moved */
    371                                                         pathsCrsr = paths + (nbPaths - 1);
    372                                                 }
    373                                                 *pathsCrsr++ = crsr + 1;
    374                                         }
    375                                         if (theChar == '\\') {
    376                                                 /* escape character. test next char */
    377                                                 char nextChar = crsr[1];
    378                                                 if (nextChar == '\\') {
    379                                                         /* rewrite the string */
    380                                                         char* rewriteCrsr = crsr + 1;
    381                                                         do {
    382                                                                 char theChar = *rewriteCrsr;
    383                                                                 rewriteCrsr[-1] = theChar;
    384                                                                 rewriteCrsr++;
    385                                                         } while (theChar != 0);
    386                                                 } else if (nextChar == ':') {
    387                                                         crsr++;
    388                                                 }
    389                                                 /* otherwise, ignore (keep the backslash) */
    390                                         }
    391                                        
    392                                         /* next char */
    393                                         crsr++;
    394                                 } while (1);
    395                                 /* null terminate the array */
    396                                 *pathsCrsr = 0;
    397                                 /* resize and save it */
    398                                 __darwintrace_sandbox_bounds = (char**) realloc(paths, sizeof(char*) * (nbPaths + 1));
    399                         }
    400                 }
    401         }
    402 #endif
    403346#undef close
    404347#undef open
     
    407350/* log a call and optionally get the real path from the fd if it's not 0.
    408351 * op:                  the operation (open, readlink, execve)
    409  * procname:    the name of the process (can be NULL)
    410352 * path:                the path of the file
    411353 * fd:                  a fd to the file, or 0 if we don't have any.
    412354 */
    413 inline void __darwintrace_log_op(const char* op, const char* procname, const char* path, int fd) {
    414 #if !DARWINTRACE_SHOW_PROCESS
    415         #pragma unused(procname)
    416 #endif
     355inline void __darwintrace_log_op(const char* op, const char* path, int fd) {
    417356        int size;
    418357        char somepath[MAXPATHLEN];
     
    447386
    448387        size = snprintf(logbuffer, sizeof(logbuffer),
    449 #if DARWINTRACE_SHOW_PROCESS
    450                 "%s[%d]\t"
    451 #endif
    452                 "%s\t%s\n",
    453 #if DARWINTRACE_SHOW_PROCESS
    454                 procname ? procname : __darwintrace_progname, __darwintrace_pid,
    455 #endif
     388                "%s\t%s",
    456389                op, somepath );
    457390
    458         write(__darwintrace_fd, logbuffer, size);
    459         fsync(__darwintrace_fd);
     391        exchange_with_port(logbuffer, size+1, 0);
     392       
     393        return;
    460394}
    461395
     
    509443}
    510444
    511 #if DARWINTRACE_SANDBOX
    512 /*
    513  * return 1 if path (once normalized) is in sandbox, 0 otherwise.
    514  * return -1 if no sandbox is defined or if the path couldn't be normalized.
    515  */
    516 inline int __darwintrace_is_in_sandbox(const char* path) {
    517         int result = -1; /* no sandbox is defined */
     445/*
     446 * return 1 if path allowed, 0 otherwise
     447 */
     448static int ask_for_dependency(char * path)
     449{
     450        char buffer[BUFFER_SIZE], *p;
     451        int result=0;
     452       
     453        strcpy(buffer, "dep_check\t");
     454        strcat(buffer, path);
     455        p=exchange_with_port(buffer, strlen(buffer), 1);
     456        if((int)p==-1||!p)
     457                return 0;
     458       
     459        if(*p=='+')
     460                result=1;
     461       
     462        free(p);
     463        return result;
     464}
     465
     466/*
     467 * exchange_with_port - routine to send/recv from/to socket
     468 * Parameters:
     469 *   buf    -- buffer with data to send
     470 *   len    -- length of data
     471 *   answer -- 1 (yes, I want to receive answer) and 0 (no, thanks, just send)
     472 * Return value:
     473 *    -1     -- something went wrong
     474 *    0      -- data successful sended
     475 *    string -- answer (caller shoud free it)
     476 */
     477static char * exchange_with_port(const char * buf, size_t len, int answer)
     478{
     479        wait_for_socket(__darwintrace_fd, 1);
     480        if(send(__darwintrace_fd, buf, len, 0)==-1)
     481                return (char*)-1;
     482        if(!answer)
     483                return 0;
     484        {
     485                size_t l=0;
     486                char * b;
     487               
     488                wait_for_socket(__darwintrace_fd, 0);
     489                recv(__darwintrace_fd, &l, sizeof(l),0);
     490                if(!l)
     491                        return 0;
     492                b=(char*)malloc(l+1);
     493                b[l]=0;
     494                recv(__darwintrace_fd, b, l, 0);
     495                return b;
     496        }
     497}
     498
     499/*
     500 * return 1 if path (once normalized) is in sandbox or redirected, 0 otherwise.
     501 */
     502inline int __darwintrace_is_in_sandbox(const char* path, char * newpath) {
     503        char * t, * p, * _;
     504        int result=-1;
     505       
    518506        __darwintrace_setup();
    519         if (__darwintrace_sandbox_bounds != NULL) {
    520                 /* check the path */
    521                 char** basePathsCrsr = __darwintrace_sandbox_bounds;
    522                 char* basepath = *basePathsCrsr++;
    523                 /* normalize the path */
    524                 char createpath[MAXPATHLEN];
    525                 if (realpath(path, createpath) != NULL) {
    526                         __darwintrace_cleanup_path(createpath);
    527                         /* say it's outside unless it's proved inside */
    528                         result = 0;
    529                         while (basepath != NULL) {
    530                                 if (__darwintrace_strbeginswith(createpath, basepath)) {
    531                                         result = 1;
     507        if(*path=='/')
     508                p=strdup(path);
     509        else
     510        {
     511                p=(char*)malloc(BUFFER_SIZE);
     512                (void) getcwd(p, BUFFER_SIZE-1);
     513                _=p+strlen(p)+1;
     514                if(_[-1]!='/')
     515                        *_++='/';
     516                strncpy(_, path, BUFFER_SIZE-(_-p));
     517        }
     518        __darwintrace_cleanup_path(p);
     519        if(!filemap)
     520                return 1;
     521        do
     522        {
     523                for(t=filemap; *t;)
     524                {
     525                        if(__darwintrace_strbeginswith(p, t))
     526                        {
     527                                t+=strlen(t);
     528                                switch(*t)
     529                                {
     530                                case 0:
     531                                        result=1;
     532                                        break;
     533                                case 1:
     534                                        if(!newpath)
     535                                        {
     536                                                result=0;
     537                                                break;
     538                                        }
     539                                        strcpy(newpath, p+1);
     540                                        _=newpath+strlen(newpath);
     541                                        if(_[-1]!='/')
     542                                                *_++='/';
     543                                        strcpy(_, p);
     544                                        result=1;
     545                                        break;
     546                                case 2:
     547                                        result=ask_for_dependency(p);
    532548                                        break;
    533549                                }
    534                                 basepath = *basePathsCrsr++;;
    535550                        }
    536                 } /* otherwise, operation will fail anyway */
    537         }
    538         return result;
    539 }
    540 #endif
     551                        if(result!=-1)
     552                                break;
     553                        t+=strlen(t)+1;
     554                        if(*t==1)
     555                                t+=strlen(t)+1;
     556                        else
     557                                t+=2;
     558                }
     559                if(result!=-1)
     560                        break;
     561                __darwintrace_log_op("sandbox_violation", path, 0);
     562                result=0;
     563        }
     564        while(0);
     565        free(p);
     566        return result;
     567}
    541568
    542569/* Log calls to open(2) into the file specified by DARWINTRACE_LOG.
     
    556583        va_list args;
    557584
     585        /* Why mode here ? */
    558586        va_start(args, flags);
    559587        mode = va_arg(args, int);
    560588        va_end(args);
    561 #if DARWINTRACE_SANDBOX
     589       
    562590        result = 0;
    563591        if (flags & (O_CREAT | O_APPEND | O_RDWR | O_WRONLY | O_TRUNC)) {
    564                 int isInSandbox = __darwintrace_is_in_sandbox(path);
    565                 if (isInSandbox == 1) {
    566                         dprintf("darwintrace: creation/writing was allowed at %s\n", path);
    567                 } else if (isInSandbox == 0) {
    568                         /* outside sandbox, but sandbox is defined: forbid */
     592                char newpath[MAXPATHLEN];
     593                int isInSandbox;
     594               
     595                *newpath=0;
     596                __darwintrace_setup();
     597                isInSandbox = __darwintrace_is_in_sandbox(path, newpath);
     598                if (isInSandbox == 0) {
    569599                        dprintf("darwintrace: creation/writing was forbidden at %s\n", path);
    570                         __darwintrace_log_op("sandbox_violation", NULL, path, 0);
    571600                        errno = EACCES;
    572601                        result = -1;
    573602                }
     603                if(*newpath)
     604                        path=newpath;
    574605        }
    575606        if (result == 0) {
    576607                result = open(path, flags, mode);
    577         }
    578 #else
    579         result = open(path, flags, mode);
    580 #endif
    581         if (result >= 0) {
    582                 /* check that it's a file */
    583                 struct stat sb;
    584                 fstat(result, &sb);
    585                 if ((sb.st_mode & S_IFDIR) == 0) {
    586                         if ((flags & (O_CREAT | O_WRONLY /*O_RDWR*/)) == 0 ) {
    587                                 __darwintrace_setup();
    588                                 if (__darwintrace_fd >= 0) {
    589                                     dprintf("darwintrace: original open path is %s\n", path);
    590                                         __darwintrace_log_op("open", NULL, path, result);
    591                                 }
    592 #if DARWINTRACE_LOG_CREATE
    593                         } else if (flags & O_CREAT) {
    594                                 __darwintrace_setup();
    595                                 if (__darwintrace_fd >= 0) {
    596                                     dprintf("darwintrace: original create path is %s\n", path);
    597                                         __darwintrace_log_op("create", NULL, path, result);
    598                                 }
    599 #endif
    600                         }
    601                 }
    602608        }
    603609        return result;
     
    616622#define readlink(x,y,z) syscall(SYS_readlink, (x), (y), (z))
    617623        ssize_t result;
     624        int isInSandbox;
    618625
    619626        result = readlink(path, buf, bufsiz);
    620627        if (result >= 0) {
    621           __darwintrace_setup();
    622           if (__darwintrace_fd >= 0) {
    623             dprintf("darwintrace: original readlink path is %s\n", path);
    624                 __darwintrace_log_op("readlink", NULL, path, 0);
    625           }
     628                __darwintrace_setup();
     629                isInSandbox = __darwintrace_is_in_sandbox(path, 0);
     630                if (!isInSandbox)
     631                {
     632                        errno=EACCES;
     633                        result=-1;
     634                }
    626635        }
    627636        return result;
     
    650659            if(S_ISLNK(sb.st_mode)) {
    651660              /* for symlinks, print both */
    652                   __darwintrace_log_op("execve", NULL, path, 0);
     661                  __darwintrace_log_op("execve", path, 0);
    653662            }
    654663               
     
    659668       
    660669                  /* once we have an open fd, if a full path was requested, do it */
    661                   __darwintrace_log_op("execve", NULL, path, fd);
     670                  __darwintrace_log_op("execve", path, fd);
    662671
    663672                  /* read the file for the interpreter */
     
    685694                        /* we have liftoff */
    686695                        if (interp && interp[0] != '\0') {
    687                           const char* procname = NULL;
    688 #if DARWINTRACE_SHOW_PROCESS
    689                           procname = strrchr(argv[0], '/') + 1;
    690                           if (procname == NULL) {
    691                                 procname = argv[0];
    692                           }
    693 #endif
    694                           __darwintrace_log_op("execve", procname, interp, 0);
     696                          __darwintrace_log_op("execve", interp, 0);
    695697                        }
    696698                  }
     
    698700                }
    699701          }
     702        close(__darwintrace_fd);
     703        __darwintrace_fd=-1;
    700704        }
    701705       
     
    729733#define __unlink(x) syscall(SYS_unlink, (x))
    730734        int result = 0;
    731         int isInSandbox = __darwintrace_is_in_sandbox(path);
     735        int isInSandbox = __darwintrace_is_in_sandbox(path, 0);
    732736        if (isInSandbox == 1) {
    733737                dprintf("darwintrace: unlink was allowed at %s\n", path);
     
    735739                /* outside sandbox, but sandbox is defined: forbid */
    736740                dprintf("darwintrace: unlink was forbidden at %s\n", path);
    737                 __darwintrace_log_op("sandbox_violation", NULL, path, 0);
    738741                errno = EACCES;
    739742                result = -1;
     
    754757#define __mkdir(x,y) syscall(SYS_mkdir, (x), (y))
    755758        int result = 0;
    756         int isInSandbox = __darwintrace_is_in_sandbox(path);
     759        int isInSandbox = __darwintrace_is_in_sandbox(path, 0);
    757760        if (isInSandbox == 1) {
    758761                dprintf("darwintrace: mkdir was allowed at %s\n", path);
     
    766769                {
    767770                        dprintf("darwintrace: mkdir was forbidden at %s\n", path);
    768                         __darwintrace_log_op("sandbox_violation", NULL, path, 0);
    769771                        errno = EACCES;
    770772                        result = -1;
     
    787789#define __rmdir(x) syscall(SYS_rmdir, (x))
    788790        int result = 0;
    789         int isInSandbox = __darwintrace_is_in_sandbox(path);
     791        int isInSandbox = __darwintrace_is_in_sandbox(path, 0);
    790792        if (isInSandbox == 1) {
    791793                dprintf("darwintrace: rmdir was allowed at %s\n", path);
     
    793795                /* outside sandbox, but sandbox is defined: forbid */
    794796                dprintf("darwintrace: removing directory %s was forbidden\n", path);
    795                 __darwintrace_log_op("sandbox_violation", NULL, path, 0);
    796797                errno = EACCES;
    797798                result = -1;
     
    812813#define __rename(x,y) syscall(SYS_rename, (x), (y))
    813814        int result = 0;
    814         int isInSandbox = __darwintrace_is_in_sandbox(from);
     815        int isInSandbox = __darwintrace_is_in_sandbox(from, 0);
    815816        if (isInSandbox == 1) {
    816817                dprintf("darwintrace: rename was allowed at %s\n", from);
     
    818819                /* outside sandbox, but sandbox is defined: forbid */
    819820                dprintf("darwintrace: renaming from %s was forbidden\n", from);
    820                 __darwintrace_log_op("sandbox_violation", NULL, from, 0);
    821821                errno = EACCES;
    822822                result = -1;
     
    824824
    825825        if (result == 0) {
    826                 isInSandbox = __darwintrace_is_in_sandbox(to);
     826                isInSandbox = __darwintrace_is_in_sandbox(to, 0);
    827827                if (isInSandbox == 1) {
    828828                        dprintf("darwintrace: rename was allowed at %s\n", to);
     
    830830                        /* outside sandbox, but sandbox is defined: forbid */
    831831                        dprintf("darwintrace: renaming to %s was forbidden\n", to);
    832                         __darwintrace_log_op("sandbox_violation", NULL, to, 0);
    833832                        errno = EACCES;
    834833                        result = -1;
  • trunk/base/src/pextlib1.0/Makefile

    r26177 r26682  
    11OBJS=           Pextlib.o strsed.o fgetln.o md5cmd.o setmode.o xinstall.o \
    22                fs-traverse.o strcasecmp.o vercomp.o filemap.o \
    3                 sha1cmd.o compat.o curl.o rmd160cmd.o readline.o uid.o
     3                sha1cmd.o compat.o curl.o rmd160cmd.o readline.o uid.o\
     4                tracelib.o
    45SHLIB_NAME=     Pextlib${SHLIB_SUFFIX}
    56INSTALLDIR= ${DESTDIR}${datadir}/macports/Tcl/pextlib1.0
  • trunk/base/src/pextlib1.0/Pextlib.c

    r26177 r26682  
    114114#include "readline.h"
    115115#include "uid.h"
     116#include "tracelib.h"
    116117
    117118#if HAVE_CRT_EXTERNS_H
     
    11661167        Tcl_CreateObjCommand(interp, "name_to_gid", name_to_gidCmd, NULL, NULL);
    11671168        Tcl_CreateObjCommand(interp, "gid_to_name", gid_to_nameCmd, NULL, NULL);
     1169       
     1170        Tcl_CreateObjCommand(interp, "tracelib", TracelibCmd, NULL, NULL);
    11681171
    11691172        if (Tcl_PkgProvide(interp, "Pextlib", "1.0") != TCL_OK)
  • trunk/base/src/port1.0/porttrace.tcl

    r26177 r26682  
    4444                        global env trace_fifo trace_sandboxbounds
    4545                        # Create a fifo.
    46                         set trace_fifo "$workpath/trace_fifo"
     46                        # path in unix socket limited to 109 chars
     47                        # # set trace_fifo "$workpath/trace_fifo"
     48                        set trace_fifo "/tmp/macports/[pid]"
     49                        file mkdir "/tmp/macports"
    4750                        file delete -force $trace_fifo
    48                         mkfifo $trace_fifo 0600
    4951                       
    5052                        # Create the thread/process.
     
    7678                                set trace_sandboxbounds "${trace_sandboxbounds}:$env(TMPDIR)"
    7779                        }
     80                        tracelib setsandbox $trace_sandboxbounds
    7881                }
    7982        }
     
    142145                        unset env(DARWINTRACE_SANDBOX_BOUNDS)
    143146                }
     147               
     148                #kill socket
     149                tracelib clean
    144150
    145151                # Clean up.
     
    181187proc slave_send {command} {
    182188        global trace_thread
     189
     190        # ui_warn "slave send $command ?"
    183191
    184192        thread::send $trace_thread "$command" result
     
    259267# Slave init method.
    260268proc slave_start {fifo p_workpath} {
    261         global ports_list trace_filemap sandbox_violation_list trace_fifo_r_chan \
    262                 trace_fifo_w_chan workpath
     269        global ports_list trace_filemap sandbox_violation_list
    263270        # Save the workpath.
    264271        set workpath $p_workpath
     
    267274        set ports_list {}
    268275        set sandbox_violation_list {}
    269         set trace_fifo_r_chan [open $fifo {RDONLY NONBLOCK}]
    270         # To prevent EOF when darwintrace closes the file, I also open the pipe
    271         # myself as write only.
    272         # This is quite ugly. The clean way to do would be to only install the
    273         # fileevent handler when the pipe is opened on the other end, but I don't
    274         # know how to wait for this while still being interruptable (i.e. while
    275         # still being able to get commands thru thread::send). Thoughts, anyone?
    276         set trace_fifo_w_chan [open $fifo w]
    277         fconfigure $trace_fifo_r_chan -blocking 0 -buffering line
    278         fileevent $trace_fifo_r_chan readable [list slave_read_line $trace_fifo_r_chan]
     276        tracelib setname $fifo
     277        tracelib run
    279278}
    280279
     
    286285        filemap close trace_filemap
    287286        # Close the pipe (both ends).
    288         close $trace_fifo_r_chan
    289         close $trace_fifo_w_chan
    290287}
    291288
     
    303300        return $sandbox_violation_list
    304301}
     302
     303proc slave_add_sandbox_violation {path} {
     304        global sandbox_violation_list
     305        lappend sandbox_violation_list $path
     306}
  • trunk/base/src/port1.0/portutil.tcl

    r26536 r26682  
    11441144                        }
    11451145
     1146                        # *** move it to good position
     1147                        #   Why do we need it? It closes socket, and exit from our C thread
     1148                        tracelib closesocket
     1149                        # ***
     1150                       
    11461151                        # Check dependencies & file creations outside workpath.
    11471152                        if {[info exists ports_trace]
Note: See TracChangeset for help on using the changeset viewer.