Ticket #1500: background.diff

File background.diff, 6.0 KB (added by IMDagger, 10 years ago)
  • src/background.c

    diff --git a/src/background.c b/src/background.c
    index 9eadd29..812b114 100644
    a b int we_are_background = 0; 
    6262/* File descriptor for talking to our parent */ 
    6363static int parent_fd; 
    6464 
     65/* File descriptor for messages from our parent */ 
     66static int from_parent_fd; 
     67 
    6568#define MAXCALLARGS 4           /* Number of arguments supported */ 
    6669 
    6770struct TaskList *task_list = NULL; 
    struct TaskList *task_list = NULL; 
    6972static int background_attention (int fd, void *closure); 
    7073     
    7174static void 
    72 register_task_running (FileOpContext *ctx, pid_t pid, int fd, char *info) 
     75register_task_running (FileOpContext *ctx, pid_t pid, int fd, int to_child, 
     76                                           char *info) 
    7377{ 
    7478    TaskList *new; 
    7579 
    register_task_running (FileOpContext *ctx, pid_t pid, int fd, char *info) 
    7983    new->state = Task_Running; 
    8084    new->next  = task_list; 
    8185    new->fd    = fd; 
     86    new->to_child_fd = to_child; 
    8287    task_list  = new; 
    8388 
    8489    add_select_channel (fd, background_attention, ctx); 
    int 
    118123do_background (struct FileOpContext *ctx, char *info) 
    119124{ 
    120125    int comm[2];                /* control connection stream */ 
     126    int back_comm[2];   /* back connection */ 
    121127    pid_t pid; 
    122128 
    123129    if (pipe (comm) == -1) 
    124130        return -1; 
    125131 
     132    if (pipe (back_comm) == -1) 
     133        return -1; 
     134 
    126135    if ((pid = fork ()) == -1) { 
    127136        int saved_errno = errno; 
    128137        (void) close (comm[0]); 
    129138        (void) close (comm[1]); 
     139        (void) close (back_comm[0]); 
     140        (void) close (back_comm[1]); 
    130141        errno = saved_errno; 
    131142        return -1; 
    132143    } 
    do_background (struct FileOpContext *ctx, char *info) 
    134145    if (pid == 0) { 
    135146        int nullfd; 
    136147 
    137         close (comm[0]); 
    138148        parent_fd = comm[1]; 
     149        from_parent_fd = back_comm[0]; 
     150         
    139151        we_are_background = 1; 
    140152        current_dlg = NULL; 
    141153 
    do_background (struct FileOpContext *ctx, char *info) 
    152164 
    153165        return 0; 
    154166    } else { 
    155         close (comm[1]); 
    156167        ctx->pid = pid; 
    157         register_task_running (ctx, pid, comm[0], info); 
     168        register_task_running (ctx, pid, comm[0], back_comm[1], info); 
    158169        return 1; 
    159170    } 
    160171} 
    background_attention (int fd, void *closure) 
    227238    int  argc, i, result, status; 
    228239    char *data [MAXCALLARGS]; 
    229240    ssize_t bytes; 
     241        struct TaskList *p; 
     242        int to_child_fd; 
    230243    enum ReturnType type; 
    231244 
    232245    ctx = closure; 
    background_attention (int fd, void *closure) 
    306319                break; 
    307320            } 
    308321 
     322        /* Find child task info by descriptor */ 
     323        for (p = task_list; p; p = p->next) { 
     324                if (p->fd == fd) 
     325                        break; 
     326        } 
     327 
     328        to_child_fd = p->to_child_fd; 
     329 
    309330        /* Send the result code and the value for shared variables */ 
    310         write (fd, &result, sizeof (int)); 
     331        write (to_child_fd, &result, sizeof (int)); 
    311332        if (have_ctx) 
    312             write (fd, ctx, sizeof (FileOpContext)); 
     333            write (to_child_fd, ctx, sizeof (FileOpContext)); 
    313334    } else if (type == Return_String) { 
    314335        int len; 
    315336        char *resstr = NULL; 
    background_attention (int fd, void *closure) 
    334355        } 
    335356        if (resstr){ 
    336357            len = strlen (resstr); 
    337             write (fd, &len, sizeof (len)); 
     358            write (to_child_fd, &len, sizeof (len)); 
    338359            if (len){ 
    339                 write (fd, resstr, len); 
     360                write (to_child_fd, resstr, len); 
    340361                g_free (resstr); 
    341362            } 
    342363        } else { 
    343364            len = 0; 
    344             write (fd, &len, sizeof (len)); 
     365            write (to_child_fd, &len, sizeof (len)); 
    345366        } 
    346367    } 
    347368    for (i = 0; i < argc; i++) 
    parent_call (void *routine, struct FileOpContext *ctx, int argc, ...) 
    395416        write (parent_fd, &len, sizeof (int)); 
    396417        write (parent_fd, value, len); 
    397418    } 
    398     read (parent_fd, &i, sizeof (int)); 
     419 
     420    read (from_parent_fd, &i, sizeof (int)); 
    399421    if (ctx) 
    400         read (parent_fd, ctx, sizeof (FileOpContext)); 
     422        read (from_parent_fd, ctx, sizeof (FileOpContext)); 
    401423 
    402424    return i; 
    403425} 
    parent_call_string (void *routine, int argc, ...) 
    420442        write (parent_fd, &len, sizeof (int)); 
    421443        write (parent_fd, value, len); 
    422444    } 
    423     read (parent_fd, &i, sizeof (int)); 
     445    read (from_parent_fd, &i, sizeof (int)); 
    424446    if (!i) 
    425447        return NULL; 
    426448    str = g_malloc (i + 1); 
    427     read (parent_fd, str, i); 
     449    read (from_parent_fd, str, i); 
    428450    str [i] = 0; 
    429451    return str; 
    430452} 
  • src/background.h

    diff --git a/src/background.h b/src/background.h
    index 266240d..8ad4d54 100644
    a b enum TaskState { 
    1717 
    1818typedef struct TaskList { 
    1919    int fd; 
     20    int to_child_fd; 
    2021    pid_t pid; 
    2122    int state; 
    2223    char *info; 
  • src/file.c

    diff --git a/src/file.c b/src/file.c
    index 15d5f70..73e4305 100644
    a b enum { 
    381381}; 
    382382 
    383383static FileProgressStatus 
    384 warn_same_file (const char *fmt, const char *a, const char *b) 
     384real_warn_same_file (enum OperationMode mode, const char *fmt, 
     385                                         const char *a, const char *b) 
    385386{ 
    386387    char *msg; 
    387388    int result = 0; 
     389    const char *head_msg; 
     390 
     391    head_msg = mode == Foreground ? MSG_ERROR : 
     392                _(" Background process error "); 
     393 
    388394    msg = g_strdup_printf (fmt, a, b); 
    389     result = query_dialog (MSG_ERROR, msg, D_ERROR, 2, _("&Skip"), _("&Abort")); 
     395    result = query_dialog (head_msg, msg, D_ERROR, 2, _("&Skip"), _("&Abort")); 
    390396    g_free(msg); 
    391397    do_refresh (); 
    392398    if ( result ) { /* 1 == Abort */ 
    warn_same_file (const char *fmt, const char *a, const char *b) 
    396402    } 
    397403} 
    398404 
     405#ifdef WITH_BACKGROUND 
     406static FileProgressStatus 
     407warn_same_file (const char *fmt, const char *a, const char *b) 
     408{ 
     409    union { 
     410        void *p; 
     411        FileProgressStatus (*f) (enum OperationMode, const char *fmt, 
     412                                 const char *a, const char *b); 
     413    } pntr; 
     414    pntr.f = real_warn_same_file; 
     415 
     416    if (we_are_background) 
     417        return parent_call (pntr.p, NULL, 3, strlen (fmt), 
     418                            fmt, strlen(a), a, strlen(b), b); 
     419    else 
     420        return real_warn_same_file (Foreground, fmt, a, b); 
     421} 
     422#else 
     423static FileProgressStatus 
     424warn_same_file (const char *fmt, const char *a, const char *b) 
     425{ 
     426    return real_warn_same_file (Foreground, fmt, a, b); 
     427} 
     428#endif 
     429 
    399430FileProgressStatus 
    400431copy_file_file (FileOpContext *ctx, const char *src_path, const char *dst_path, 
    401432                int ask_overwrite, off_t *progress_count,