Changeset 5540

Show
Ignore:
Timestamp:
05/28/08 14:06:26 (3 months ago)
Author:
morris
Message:

Open transfer files before notifying client of readiness, to catch and send any errors during open

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • wired/trunk/wired/server.c

    r5504 r5540  
    517517 
    518518void wd_reply_error(void) { 
    519         switch(wi_error_code()) { 
     519        if(wi_error_domain() == WI_ERROR_DOMAIN_ERRNO) 
     520                wd_reply_errno(wi_error_code()); 
     521        else 
     522                wd_reply(500, WI_STR("Command Failed")); 
     523} 
     524 
     525 
     526 
     527void wd_reply_errno(int error) { 
     528        switch(error) { 
    520529                case ENOENT: 
    521530                        wd_reply(520, WI_STR("File or Directory Not Found")); 

  • wired/trunk/wired/server.h

    r5196 r5540  
    5555void                                                            wd_reply(uint32_t, wi_string_t *, ...); 
    5656void                                                            wd_reply_error(void); 
     57void                                                            wd_reply_errno(int); 
    5758void                                                            wd_sreply(wi_socket_t *, uint32_t, wi_string_t *, ...); 
    5859void                                                            wd_broadcast(wd_chat_t *, uint32_t, wi_string_t *, ...); 

  • wired/trunk/wired/transfers.c

    r5527 r5540  
    6262static void                                                             wd_transfer_set_state(wd_transfer_t *, wd_transfer_state_t); 
    6363 
     64static wi_boolean_t                                             wd_transfer_open(wd_transfer_t *); 
     65static void                                                             wd_transfer_close(wd_transfer_t *); 
    6466static void                                                             wd_transfer_download(wd_transfer_t *); 
    6567static void                                                             wd_transfer_upload(wd_transfer_t *); 
    …… 
    334336                                        transfer->waiting_time = wi_time_interval(); 
    335337                                         
    336                                         wd_user_lock_socket(transfer->user); 
    337                                         wd_sreply(wd_user_socket(transfer->user), 400, WI_STR("%#@%c%llu%c%#@"), 
    338                                                           transfer->path,               WD_FIELD_SEPARATOR, 
    339                                                           transfer->offset,             WD_FIELD_SEPARATOR, 
    340                                                           transfer->hash); 
    341                                         wd_user_unlock_socket(transfer->user); 
    342                                          
    343                                         transfer->timer = wi_timer_init_with_function(wi_timer_alloc(), 
    344                                                                                                                                   wd_transfer_expire_timer, 
    345                                                                                                                                   WD_TRANSFERS_WAITING_INTERVAL, 
    346                                                                                                                                   false); 
    347                                         wi_timer_set_data(transfer->timer, transfer); 
    348                                         wi_timer_schedule(transfer->timer); 
    349                                          
    350                                         if(transfer->type == WD_TRANSFER_DOWNLOAD) { 
    351                                                 wd_transfers_active_downloads++; 
    352                                                 wd_user_increase_downloads(transfer->user); 
    353                                         } else { 
    354                                                 wd_transfers_active_uploads++; 
    355                                                 wd_user_increase_uploads(transfer->user); 
     338                                        if(wd_transfer_open(transfer)) { 
     339                                                wd_user_lock_socket(transfer->user); 
     340                                                wd_sreply(wd_user_socket(transfer->user), 400, WI_STR("%#@%c%llu%c%#@"), 
     341                                                                  transfer->path,               WD_FIELD_SEPARATOR, 
     342                                                                  transfer->offset,             WD_FIELD_SEPARATOR, 
     343                                                                  transfer->hash); 
     344                                                wd_user_unlock_socket(transfer->user); 
     345                                                 
     346                                                transfer->timer = wi_timer_init_with_function(wi_timer_alloc(), 
     347                                                                                                                                          wd_transfer_expire_timer, 
     348                                                                                                                                          WD_TRANSFERS_WAITING_INTERVAL, 
     349                                                                                                                                          false); 
     350                                                wi_timer_set_data(transfer->timer, transfer); 
     351                                                wi_timer_schedule(transfer->timer); 
     352                                                 
     353                                                if(transfer->type == WD_TRANSFER_DOWNLOAD) { 
     354                                                        wd_transfers_active_downloads++; 
     355                                                        wd_user_increase_downloads(transfer->user); 
     356                                                } else { 
     357                                                        wd_transfers_active_uploads++; 
     358                                                        wd_user_increase_uploads(transfer->user); 
     359                                                } 
    356360                                        } 
    357361                                } 
    …… 
    409413        transfer->hash                  = wi_retain(wi_data_sha1(wi_data_with_random_bytes(1024))); 
    410414        transfer->state_lock    = wi_condition_lock_init_with_condition(wi_condition_lock_alloc(), transfer->state); 
     415        transfer->fd                    = -1; 
    411416 
    412417        return transfer; 
    …… 
    573578 
    574579        wi_lock_unlock(wd_transfers_update_queue_lock); 
     580} 
     581 
     582 
     583 
     584static wi_boolean_t wd_transfer_open(wd_transfer_t *transfer) { 
     585        if(transfer->type == WD_TRANSFER_DOWNLOAD) 
     586                transfer->fd = open(wi_string_cstring(transfer->realpath), O_RDONLY, 0); 
     587        else 
     588                transfer->fd = open(wi_string_cstring(transfer->realpath), O_WRONLY | O_APPEND | O_CREAT, 0666); 
     589         
     590        if(transfer->fd < 0) { 
     591                wi_log_err(WI_STR("Could not open %@: %s"), 
     592                        transfer->realpath, strerror(errno)); 
     593                wd_reply_errno(errno); 
     594 
     595                return false; 
     596        } 
     597         
     598        return true; 
     599} 
     600 
     601 
     602 
     603static void wd_transfer_close(wd_transfer_t *transfer) { 
     604        wi_socket_close(transfer->socket); 
     605         
     606        if(transfer->fd >= 0) 
     607                close(transfer->fd); 
    575608} 
    576609 
    …… 
    587620        ssize_t                                 bytes, speedbytes, statsbytes; 
    588621        wi_uinteger_t                   i = 0; 
    589         int                                             fd, sd, result, error, line; 
     622        int                                             sd, result, error, line; 
    590623 
    591624        pool = wi_pool_init(wi_pool_alloc()); 
    …… 
    602635        account = wd_user_account(transfer->user); 
    603636 
    604         /* open local file */ 
    605         fd = open(wi_string_cstring(transfer->realpath), O_RDONLY, 0); 
    606  
    607         if(fd < 0) { 
    608                 wi_log_err(WI_STR("Could not open %@: %s"), 
    609                         transfer->realpath, strerror(errno)); 
    610  
    611                 goto end; 
    612         } 
    613  
    614         lseek(fd, transfer->offset, SEEK_SET); 
     637        /* seek to offset */ 
     638        lseek(transfer->fd, transfer->offset, SEEK_SET); 
    615639 
    616640        /* update status */ 
    …… 
    623647        while(transfer->state == WD_TRANSFER_RUNNING && transfer->transferred < transfer->size) { 
    624648                /* read data */ 
    625                 bytes = read(fd, buffer, sizeof(buffer)); 
     649                bytes = read(transfer->fd, buffer, sizeof(buffer)); 
    626650 
    627651                if(bytes <= 0) { 
    …… 
    743767        wi_lock_unlock(wd_status_lock); 
    744768 
    745 end: 
    746         wi_socket_close(transfer->socket); 
    747  
    748         if(fd >= 0) 
    749                 close(fd); 
     769        wd_transfer_close(transfer); 
    750770         
    751771        wi_release(pool); 
    …… 
    765785        ssize_t                                 result, speedbytes, statsbytes; 
    766786        wi_uinteger_t                   i = 0; 
    767         int                                             sd, fd, bytes, error, line; 
     787        int                                             sd, bytes, error, line; 
    768788 
    769789        pool = wi_pool_init(wi_pool_alloc()); 
    …… 
    779799        speedbytes = statsbytes = 0; 
    780800        account = wd_user_account(transfer->user); 
    781  
    782         /* open the file */ 
    783         fd = open(wi_string_cstring(transfer->realpath), O_WRONLY | O_APPEND | O_CREAT, 0666); 
    784  
    785         if(fd < 0) { 
    786                 wi_log_err(WI_STR("Could not open %@: %s"), 
    787                         transfer->realpath, strerror(errno)); 
    788  
    789                 goto end; 
    790         } 
    791801 
    792802        /* update status */ 
    …… 
    841851 
    842852                /* write data */ 
    843                 result = write(fd, buffer, bytes); 
     853                result = write(transfer->fd, buffer, bytes); 
    844854                 
    845855                if(result <= 0) { 
    …… 
    922932        } 
    923933 
    924 end: 
    925         wi_socket_close(transfer->socket); 
    926  
    927         if(fd >= 0) 
    928                 close(fd); 
     934        wd_transfer_close(transfer); 
    929935         
    930936        wi_release(pool); 

  • wired/trunk/wired/transfers.h

    r5501 r5540  
    6565        wi_string_t                                                     *path; 
    6666        wi_string_t                                                     *realpath; 
     67         
     68        int                                                                     fd; 
    6769 
    6870        wi_condition_lock_t                                     *state_lock;