Changeset 964 for trunk/src


Ignore:
Timestamp:
05/25/07 21:11:36 (5 years ago)
Author:
aj
Message:

indent changes only.

Location:
trunk/src/ifd
Files:
36 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/ifd/atr.c

    r826 r964  
    157157} 
    158158 
    159 int 
    160 ifd_pts_complete(const unsigned char *pts, size_t len) 
     159int ifd_pts_complete(const unsigned char *pts, size_t len) 
    161160{ 
    162        unsigned int j=2; 
     161        unsigned int j = 2; 
    163162 
    164        if (j > len) 
    165                return 0; 
    166        j =+ ifd_count_bits(pts[1] & 0x70); 
    167        j++; 
    168        if (j > len) 
    169                return 0; 
    170        return 1; 
     163        if (j > len) 
     164                return 0; 
     165        j = +ifd_count_bits(pts[1] & 0x70); 
     166        j++; 
     167        if (j > len) 
     168                return 0; 
     169        return 1; 
    171170} 
    172  

  • trunk/src/ifd/conf.c

    r946 r964  
    196196 * Config node handling 
    197197 */ 
    198 static ifd_conf_node_t *conf_add_node(ifd_conf_node_t * parent, const char *name) 
     198static ifd_conf_node_t *conf_add_node(ifd_conf_node_t * parent, 
     199                                      const char *name) 
    199200{ 
    200201        ifd_conf_node_t **p, *node; 

  • trunk/src/ifd/ctbcs.c

    r947 r964  
    6161 */ 
    6262static int ctbcs_build_verify_apdu(unsigned char *cmd, size_t size, 
    63                             unsigned char ins, unsigned char p1, 
    64                             const char *prompt, unsigned int timeout, 
    65                             const unsigned char *data, size_t data_len) 
     63                                   unsigned char ins, unsigned char p1, 
     64                                   const char *prompt, unsigned int timeout, 
     65                                   const unsigned char *data, size_t data_len) 
    6666{ 
    6767        ct_buf_t buf; 

  • trunk/src/ifd/ifd-cardman.c

    r950 r964  
    342342 */ 
    343343static int cm_usb_int(ifd_device_t * dev, int requesttype, int request, 
    344                int value, int idx, const void *sbuf, size_t slen, void *rbuf, 
    345                size_t rlen, complete_fn_t complete, long timeout) 
     344                      int value, int idx, const void *sbuf, size_t slen, 
     345                      void *rbuf, size_t rlen, complete_fn_t complete, 
     346                      long timeout) 
    346347{ 
    347348        ifd_usb_capture_t *cap; 

  • trunk/src/ifd/ifd-ccid.c

    r959 r964  
    495495        r = i = 0; 
    496496        memset(&conf, 0, sizeof(conf)); 
    497         for (c = 0; c <de.bNumConfigurations; c++) { 
     497        for (c = 0; c < de.bNumConfigurations; c++) { 
    498498                if (ifd_usb_get_config(dev, c, &conf)) { 
    499499                        ct_error("ccid: config descriptor %d not found", c); 
    … …  
    828828 
    829829                if (st->proto_support & SUPPORT_ESCAPE 
    830                     && slot == reader->nslots-1) { 
    831                         ifd_debug(1, "virtual escape slot, setting card present\n"); 
     830                    && slot == reader->nslots - 1) { 
     831                        ifd_debug(1, 
     832                                  "virtual escape slot, setting card present\n"); 
    832833                        *status = IFD_CARD_PRESENT; 
    833834                        return 0; 
    … …  
    898899} 
    899900 
    900 static int ccid_set_protocol(ifd_reader_t *reader, int s, int proto); 
     901static int ccid_set_protocol(ifd_reader_t * reader, int s, int proto); 
    901902 
    902903/* 
    … …  
    918919                return IFD_ERROR_NO_CARD; 
    919920 
    920         if (st->proto_support & SUPPORT_ESCAPE 
    921             && slot == reader->nslots-1) { 
     921        if (st->proto_support & SUPPORT_ESCAPE && slot == reader->nslots - 1) { 
    922922                ifd_debug(1, "slot: %d, setting atr to 0xff", slot); 
    923923                *((char *)atr) = 0xff; 
    … …  
    973973        if ((st->proto_support & SUPPORT_ESCAPE) 
    974974            && (proto != IFD_PROTOCOL_ESCAPE) 
    975             && (s == reader->nslots-1)) { 
     975            && (s == reader->nslots - 1)) { 
    976976                ct_error("reader doesn't support this protocol at this slot\n"); 
    977977                return IFD_ERROR_NOT_SUPPORTED; 
    … …  
    998998                        return IFD_ERROR_NOT_SUPPORTED; 
    999999                } 
    1000                 if (s != reader->nslots-1) { 
    1001                         ct_error("reader doesn't support this protocol at this slot"); 
     1000                if (s != reader->nslots - 1) { 
     1001                        ct_error 
     1002                            ("reader doesn't support this protocol at this slot"); 
    10021003                        return IFD_ERROR_NOT_SUPPORTED; 
    10031004                } 
    1004                 p = ifd_protocol_new(IFD_PROTOCOL_ESCAPE,reader, slot->dad); 
     1005                p = ifd_protocol_new(IFD_PROTOCOL_ESCAPE, reader, slot->dad); 
    10051006                if (!p) { 
    10061007                        ct_error("%s: internal error", reader->name); 
    … …  
    11641165} 
    11651166 
    1166 static int ccid_escape(ifd_reader_t *reader, int slot, void *sbuf, 
     1167static int ccid_escape(ifd_reader_t * reader, int slot, void *sbuf, 
    11671168                       size_t slen, void *rbuf, size_t rlen) 
    11681169{ 
    1169      unsigned char sendbuf[CCID_MAX_MSG_LEN]; 
    1170      unsigned char recvbuf[CCID_MAX_MSG_LEN]; 
    1171      int r; 
    1172  
    1173      ifd_debug(1, "slot: %d, slen %d, rlen %d", slot, slen, rlen); 
    1174  
    1175      r = ccid_prepare_cmd(reader, sendbuf, sizeof(sendbuf), slot, 
    1176                           CCID_CMD_ESCAPE, NULL, sbuf, slen); 
    1177      if (r < 0) 
    1178           return r; 
    1179  
    1180      r = ccid_command(reader, &sendbuf[0], r, recvbuf, sizeof(recvbuf)); 
    1181      if (r < 0) 
    1182           return r; 
    1183  
    1184      return ccid_extract_data(&recvbuf, r, rbuf, rlen); 
     1170        unsigned char sendbuf[CCID_MAX_MSG_LEN]; 
     1171        unsigned char recvbuf[CCID_MAX_MSG_LEN]; 
     1172        int r; 
     1173 
     1174        ifd_debug(1, "slot: %d, slen %d, rlen %d", slot, slen, rlen); 
     1175 
     1176        r = ccid_prepare_cmd(reader, sendbuf, sizeof(sendbuf), slot, 
     1177                             CCID_CMD_ESCAPE, NULL, sbuf, slen); 
     1178        if (r < 0) 
     1179                return r; 
     1180 
     1181        r = ccid_command(reader, &sendbuf[0], r, recvbuf, sizeof(recvbuf)); 
     1182        if (r < 0) 
     1183                return r; 
     1184 
     1185        return ccid_extract_data(&recvbuf, r, rbuf, rlen); 
    11851186} 
    11861187 

  • trunk/src/ifd/ifd-cm4000.c

    r933 r964  
    2727{ 
    2828        ifd_device_t *dev; 
    29         ifd_device_params_t params; 
     29        ifd_device_params_t params; 
    3030 
    3131        reader->name = "OMNIKEY CardMan 4000"; 

  • trunk/src/ifd/ifd-egate.c

    r905 r964  
    4444{ 
    4545        ifd_device_t *dev; 
    46         ifd_device_params_t params; 
     46        ifd_device_params_t params; 
    4747 
    4848        ifd_debug(1, "device=%s", device_name); 
    … …  
    106106        /* Reset the device */ 
    107107        rc = ifd_usb_control(dev, EGATE_DIR_OUT, EGATE_CMD_RESET, 
    108                              0, 0, NULL, 0, EG_TIMEOUT*2); 
     108                             0, 0, NULL, 0, EG_TIMEOUT * 2); 
    109109        if (rc < 0) { 
    110110              failed: 
    … …  
    197197        unsigned char cmdbuf[5]; 
    198198        int i; 
    199          
     199 
    200200        stat = eg_status(reader); 
    201201        if (stat != EGATE_STATUS_READY) { 
    202                 for (i=0; i < 4; i++) { 
     202                for (i = 0; i < 4; i++) { 
    203203                        ifd_debug(2, "device not ready, attempting reset"); 
    204204                        rc = ifd_usb_control(reader->device, EGATE_DIR_OUT, 
    205                                 EGATE_CMD_RESET, 0, 0, NULL, 0, EG_TIMEOUT); 
     205                                             EGATE_CMD_RESET, 0, 0, NULL, 0, 
     206                                             EG_TIMEOUT); 
    206207                        if (rc < 0) 
    207208                                return IFD_ERROR_COMM_ERROR; 
    … …  
    214215                        } 
    215216                        ifd_debug(2, "reset failed"); 
    216                 } 
     217                } 
    217218                ifd_debug(2, "giving up on reset"); 
    218219                return IFD_ERROR_COMM_ERROR; 
    … …  
    247248                stat = eg_status(reader); 
    248249        } 
    249         bytesread=0; 
    250          
     250        bytesread = 0; 
     251 
    251252        while (stat == EGATE_STATUS_DATA && bytesread < iso.le) { 
    252253                rc = ifd_usb_control(reader->device, EGATE_DIR_IN, 
    253                                      EGATE_CMD_READ, 0, 0,  
    254                                      (void *)(((unsigned char *)outbuffer) +  
     254                                     EGATE_CMD_READ, 0, 0, 
     255                                     (void *)(((unsigned char *)outbuffer) + 
    255256                                              bytesread), 
    256257                                     iso.le - bytesread, EG_TIMEOUT); 

  • trunk/src/ifd/ifd-etoken.c

    r891 r964  
    2222{ 
    2323        ifd_device_t *dev; 
    24         ifd_device_params_t params; 
     24        ifd_device_params_t params; 
    2525 
    2626        reader->name = "Aladdin eToken PRO"; 
    … …  
    3434        } 
    3535 
    36         params = dev->settings; 
    37         params.usb.interface = 0; 
    38         if (ifd_device_set_parameters(dev, &params) < 0) { 
    39                 ct_error("etoken: setting parameters failed", device_name); 
    40                 ifd_device_close(dev); 
    41                 return -1; 
    42         } 
     36        params = dev->settings; 
     37        params.usb.interface = 0; 
     38        if (ifd_device_set_parameters(dev, &params) < 0) { 
     39                ct_error("etoken: setting parameters failed", device_name); 
     40                ifd_device_close(dev); 
     41                return -1; 
     42        } 
    4343 
    4444        reader->device = dev; 

  • trunk/src/ifd/ifd-etoken64.c

    r950 r964  
    3131        } 
    3232 
    33         params = dev->settings; 
    34         params.usb.interface = 0; 
    35         if (ifd_device_set_parameters(dev, &params) < 0) { 
    36                 ct_error("etoken64: setting parameters failed", device_name); 
    37                 ifd_device_close(dev); 
    38                 return -1; 
    39         } 
     33        params = dev->settings; 
     34        params.usb.interface = 0; 
     35        if (ifd_device_set_parameters(dev, &params) < 0) { 
     36                ct_error("etoken64: setting parameters failed", device_name); 
     37                ifd_device_close(dev); 
     38                return -1; 
     39        } 
    4040 
    4141        reader->device = dev; 

  • trunk/src/ifd/ifd-eutron.c

    r891 r964  
    3535        ifd_device_t *dev; 
    3636        eut_priv_t *priv; 
    37         ifd_device_params_t params; 
     37        ifd_device_params_t params; 
    3838 
    3939        reader->name = "Eutron CryptoIdendity"; 
    … …  
    4747        } 
    4848 
    49         params = dev->settings; 
    50         params.usb.interface = 0; 
    51         if (ifd_device_set_parameters(dev, &params) < 0) { 
    52                 ct_error("eutron: setting parameters failed", device_name); 
    53                 ifd_device_close(dev); 
    54                 return -1; 
    55         } 
     49        params = dev->settings; 
     50        params.usb.interface = 0; 
     51        if (ifd_device_set_parameters(dev, &params) < 0) { 
     52                ct_error("eutron: setting parameters failed", device_name); 
     53                ifd_device_close(dev); 
     54                return -1; 
     55        } 
    5656 
    5757        priv = (eut_priv_t *) calloc(1, sizeof(eut_priv_t)); 

  • trunk/src/ifd/ifd-gempc.c

    r950 r964  
    675675 */ 
    676676static int __gpc_command(ifd_reader_t * reader, const void *cmd, 
    677                   size_t cmd_len, void *res, size_t res_len, int *gpc_status) 
     677                         size_t cmd_len, void *res, size_t res_len, 
     678                         int *gpc_status) 
    678679{ 
    679680        gpc_status_t *st = (gpc_status_t *) reader->driver_data; 
    … …  
    721722 
    722723static int gpc_command(ifd_reader_t * reader, const void *cmd, size_t cmd_len, 
    723                 void *res, size_t res_len) 
     724                       void *res, size_t res_len) 
    724725{ 
    725726        int rc, status; 

  • trunk/src/ifd/ifd-ikey2k.c

    r930 r964  
    1616{ 
    1717        ifd_device_t *dev; 
    18         ifd_device_params_t params; 
     18        ifd_device_params_t params; 
    1919 
    2020        reader->name = "Rainbow iKey 2032"; 
    … …  
    2828        } 
    2929 
    30         params = dev->settings; 
    31         params.usb.interface = 0; 
    32         if (ifd_device_set_parameters(dev, &params) < 0) { 
    33                 ct_error("ikey2k: setting parameters failed", device_name); 
    34                 ifd_device_close(dev); 
    35                 return -1; 
    36         } 
     30        params = dev->settings; 
     31        params.usb.interface = 0; 
     32        if (ifd_device_set_parameters(dev, &params) < 0) { 
     33                ct_error("ikey2k: setting parameters failed", device_name); 
     34                ifd_device_close(dev); 
     35                return -1; 
     36        } 
    3737 
    3838        reader->device = dev; 

  • trunk/src/ifd/ifd-ikey3k.c

    r930 r964  
    1616{ 
    1717        ifd_device_t *dev; 
    18         ifd_device_params_t params; 
     18        ifd_device_params_t params; 
    1919 
    2020        reader->name = "Rainbow iKey 3000"; 
    … …  
    2828        } 
    2929 
    30         params = dev->settings; 
    31         params.usb.interface = 0; 
    32         if (ifd_device_set_parameters(dev, &params) < 0) { 
    33                 ct_error("ikey3k: setting parameters failed", device_name); 
    34                 ifd_device_close(dev); 
    35                 return -1; 
    36         } 
     30        params = dev->settings; 
     31        params.usb.interface = 0; 
     32        if (ifd_device_set_parameters(dev, &params) < 0) { 
     33                ct_error("ikey3k: setting parameters failed", device_name); 
     34                ifd_device_close(dev); 
     35                return -1; 
     36        } 
    3737 
    3838        reader->device = dev; 

  • trunk/src/ifd/ifd-smartboard.c

    r950 r964  
    337337 
    338338static int smartboard_command(ifd_reader_t * reader, unsigned char cmd, 
    339                        const unsigned char *arg, size_t arg_len, 
    340                        unsigned char *code, void *res, size_t res_len) 
     339                              const unsigned char *arg, size_t arg_len, 
     340                              unsigned char *code, void *res, size_t res_len) 
    341341{ 
    342342        int n = 0, rc; 

  • trunk/src/ifd/ifd-starkey.c

    r891 r964  
    1717{ 
    1818        ifd_device_t *dev; 
    19         ifd_device_params_t params; 
     19        ifd_device_params_t params; 
    2020 
    2121        reader->name = "G&D Starkey 100"; 
    … …  
    2929        } 
    3030 
    31         params = dev->settings; 
    32         params.usb.interface = 0; 
    33         if (ifd_device_set_parameters(dev, &params) < 0) { 
    34                 ct_error("starkey: setting parameters failed", device_name); 
    35                 ifd_device_close(dev); 
    36                 return -1; 
    37         } 
     31        params = dev->settings; 
     32        params.usb.interface = 0; 
     33        if (ifd_device_set_parameters(dev, &params) < 0) { 
     34                ct_error("starkey: setting parameters failed", device_name); 
     35                ifd_device_close(dev); 
     36                return -1; 
     37        } 
    3838 
    3939        reader->device = dev; 
    … …  
    6969 */ 
    7070static int starkey_card_reset(ifd_reader_t * reader, int slot, void *atr, 
    71                          size_t size) 
     71                              size_t size) 
    7272{ 
    7373        ifd_device_t *dev = reader->device; 
    … …  
    7676        ifd_usb_capture_t *cap; 
    7777 
    78         rc = ifd_usb_begin_capture(dev, 
    79                 IFD_USB_URB_TYPE_INTERRUPT, 0x81, sizeof(buffer), &cap); 
    80         if (rc < 0) 
    81                 return rc; 
     78        rc = ifd_usb_begin_capture(dev, 
     79                                   IFD_USB_URB_TYPE_INTERRUPT, 0x81, 
     80                                   sizeof(buffer), &cap); 
     81        if (rc < 0) 
     82                return rc; 
    8283 
    8384        rc = ifd_usb_capture(dev, cap, buffer, sizeof(buffer), STARKEY_TIMEOUT); 
    … …  
    8990 
    9091        memcpy(atr, buffer, rc); 
    91         atrlen=rc; 
     92        atrlen = rc; 
    9293        return atrlen; 
    9394} 
    … …  
    9798 */ 
    9899static int starkey_send(ifd_reader_t * reader, unsigned int dad, 
    99                    const unsigned char *buffer, size_t len) 
     100                        const unsigned char *buffer, size_t len) 
    100101{ 
    101102        return ifd_usb_control(reader->device, 0x40, 0x06, 0, 0, 
    … …  
    104105 
    105106static int starkey_recv(ifd_reader_t * reader, unsigned int dad, 
    106                    unsigned char *buffer, size_t len, long timeout) 
     107                        unsigned char *buffer, size_t len, long timeout) 
    107108{ 
    108109        return ifd_usb_control(reader->device, 0xc0, 0x86, 0, 0, 

  • trunk/src/ifd/ifd-towitoko.c

    r950 r964  
    209209 
    210210static int twt_try_reset(ifd_reader_t * reader, const void *cmd, size_t cmd_len, 
    211                   void *atr, size_t atr_len) 
     211                        void *atr, size_t atr_len) 
    212212{ 
    213213        ifd_device_t *dev = reader->device; 
    … …  
    464464 
    465465static int twt_sync_read(ifd_reader_t * reader, int slot, int proto, 
    466                   unsigned short addr, unsigned char *buffer, size_t len) 
     466                        unsigned short addr, unsigned char *buffer, size_t len) 
    467467{ 
    468468        int r; 
    … …  
    584584 
    585585static int twt_sync_write(ifd_reader_t * reader, int slot, int proto, 
    586                    unsigned short addr, const unsigned char *buffer, size_t len) 
     586                          unsigned short addr, const unsigned char *buffer, 
     587                          size_t len) 
    587588{ 
    588589        int r; 
    … …  
    609610 */ 
    610611static int twt_command(ifd_reader_t * reader, const void *cmd, size_t cmd_len, 
    611                 void *res, size_t res_len) 
     612                       void *res, size_t res_len) 
    612613{ 
    613614        unsigned char buffer[254]; 

  • trunk/src/ifd/ifd-wbeiuu.c

    r956 r964  
    123123        int status; 
    124124        ifd_device_t *dev; 
    125         ifd_device_params_t params; 
     125        ifd_device_params_t params; 
    126126 
    127127        ifd_debug(1, "%s:%d wbeiuu_open()", __FILE__, __LINE__); 
    … …  
    147147        } 
    148148 
    149         params = dev->settings; 
    150         params.usb.interface = 0; 
    151         if (ifd_device_set_parameters(dev, &params) < 0) { 
    152                 ct_error("wbeiuu: setting parameters failed", dev_name); 
    153                 ifd_device_close(dev); 
    154                 return -1; 
    155         } 
     149        params = dev->settings; 
     150        params.usb.interface = 0; 
     151        if (ifd_device_set_parameters(dev, &params) < 0) { 
     152                ct_error("wbeiuu: setting parameters failed", dev_name); 
     153                ifd_device_close(dev); 
     154                return -1; 
     155        } 
    156156 
    157157        reader->device = dev; 

  • trunk/src/ifd/ifdhandler.c

    r955 r964  
    122122                        return 1; 
    123123                } 
    124                 snprintf(path,PATH_MAX,"%d",r); 
    125                 opt_reader=strdup(path); 
     124                snprintf(path, PATH_MAX, "%d", r); 
     125                opt_reader = strdup(path); 
    126126        } 
    127127 
    … …  
    155155        /* Create reader */ 
    156156        { 
    157                 char *typedev = malloc(strlen(type)+strlen(device)+2); 
     157                char *typedev = malloc(strlen(type) + strlen(device) + 2); 
    158158                if (!typedev) { 
    159159                        ct_error("out of memory"); 
    160160                        return 1; 
    161161                } 
    162                 sprintf(typedev,"%s:%s",type,device); 
     162                sprintf(typedev, "%s:%s", type, device); 
    163163                if (!(reader = ifd_open(driver, typedev))) { 
    164                         ct_error("unable to open reader %s %s %s", driver, type, device); 
     164                        ct_error("unable to open reader %s %s %s", driver, type, 
     165                                 device); 
    165166                        return 1; 
    166167                } 
    … …  
    195196        int rc; 
    196197        struct sigaction act; 
    197         char path[PATH_MAX]; 
    198  
    199         if (! ct_format_path(path, PATH_MAX, opt_reader)) { 
     198        char path[PATH_MAX]; 
     199 
     200        if (!ct_format_path(path, PATH_MAX, opt_reader)) { 
    200201                ct_error("ct_format_path failed!"); 
    201202                exit(1); 

  • trunk/src/ifd/ifdproxy.c

    r951 r964  
    177177        char path[PATH_MAX]; 
    178178 
    179         if (! ct_format_path(path, PATH_MAX, opt_server_port)) { 
     179        if (!ct_format_path(path, PATH_MAX, opt_server_port)) { 
    180180                return -1; 
    181181        } 
    182  
    183182 
    184183        if (argc != 0) 

  • trunk/src/ifd/pcmcia-block.c

    r922 r964  
    7474        return n; 
    7575 
    76       timeout:          /* Timeouts are a little special; they may happen e.g. 
    77                         * when trying to obtain the ATR */ 
     76      timeout:                  /* Timeouts are a little special; they may happen e.g. 
     77                                * when trying to obtain the ATR */ 
    7878        if (!ct_config.suppress_errors) 
    7979                ct_error("%s: timed out while waiting for input", dev->name); 
    … …  
    8585 */ 
    8686static int ifd_pcmcia_block_set_params(ifd_device_t * dev, 
    87                           const ifd_device_params_t * params) 
     87                                       const ifd_device_params_t * params) 
    8888{ 
    89         /* nothing to do so far */ 
    90         dev->settings = *params; 
    91         return 0; 
     89        /* nothing to do so far */ 
     90        dev->settings = *params; 
     91        return 0; 
    9292} 
    9393 

  • trunk/src/ifd/pcmcia.c

    r922 r964  
    9393 */ 
    9494static int ifd_pcmcia_set_params(ifd_device_t * dev, 
    95                           const ifd_device_params_t * params) 
     95                                const ifd_device_params_t * params) 
    9696{ 
    9797        /* nothing to do so far */ 
    98         dev->settings = *params; 
     98        dev->settings = *params; 
    9999        return 0; 
    100100} 

  • trunk/src/ifd/process.c

    r948 r964  
    169169 */ 
    170170static int do_status(ifd_reader_t * reader, int unit, ct_tlv_parser_t * args, 
    171               ct_tlv_builder_t * resp) 
     171                     ct_tlv_builder_t * resp) 
    172172{ 
    173173        int n, rc, status; 
    … …  
    204204 */ 
    205205static int do_output(ifd_reader_t * reader, int unit, ct_tlv_parser_t * args, 
    206               ct_tlv_builder_t * resp) 
     206                     ct_tlv_builder_t * resp) 
    207207{ 
    208208        char msgbuf[128]; 
    … …  
    223223 */ 
    224224static int do_lock(ct_socket_t * sock, ifd_reader_t * reader, int unit, 
    225             ct_tlv_parser_t * args, ct_tlv_builder_t * resp) 
     225                   ct_tlv_parser_t * args, ct_tlv_builder_t * resp) 
    226226{ 
    227227        unsigned int lock_type; 
    … …  
    244244 
    245245static int do_unlock(ct_socket_t * sock, ifd_reader_t * reader, int unit, 
    246               ct_tlv_parser_t * args, ct_tlv_builder_t * resp) 
     246                     ct_tlv_parser_t * args, ct_tlv_builder_t * resp) 
    247247{ 
    248248        ct_lock_handle lock; 
    … …  
    265265 */ 
    266266static int do_reset(ifd_reader_t * reader, int unit, ct_tlv_parser_t * args, 
    267              ct_tlv_builder_t * resp) 
     267                    ct_tlv_builder_t * resp) 
    268268{ 
    269269        unsigned char atr[64]; 
    … …  
    298298 */ 
    299299static int do_eject(ifd_reader_t * reader, int unit, ct_tlv_parser_t * args, 
    300              ct_tlv_builder_t * resp) 
     300                    ct_tlv_builder_t * resp) 
    301301{ 
    302302        char msgbuf[128]; 
    … …  
    324324 */ 
    325325static int do_verify(ifd_reader_t * reader, int unit, ct_tlv_parser_t * args, 
    326               ct_tlv_builder_t * resp) 
     326                     ct_tlv_builder_t * resp) 
    327327{ 
    328328        char msgbuf[128]; 
    … …  
    358358 */ 
    359359static int do_transact(ifd_reader_t * reader, int unit, ct_tlv_parser_t * args, 
    360                 ct_tlv_builder_t * resp) 
     360                       ct_tlv_builder_t * resp) 
    361361{ 
    362362        unsigned char replybuf[258]; 
    … …  
    384384 
    385385static int do_transact_old(ifd_reader_t * reader, int unit, ct_buf_t * args, 
    386                     ct_buf_t * resp) 
     386                           ct_buf_t * resp) 
    387387{ 
    388388        int rc; 
    … …  
    398398} 
    399399 
    400 static int do_set_protocol(ifd_reader_t * reader, int unit, ct_tlv_parser_t * args, 
    401                     ct_tlv_builder_t * resp) 
     400static int do_set_protocol(ifd_reader_t * reader, int unit, 
     401                           ct_tlv_parser_t * args, ct_tlv_builder_t * resp) 
    402402{ 
    403403        unsigned int protocol = 0xFF; 
    … …  
    420420 * Synchronous ICC read/write 
    421421 */ 
    422 static int do_memory_write(ifd_reader_t * reader, int unit, ct_tlv_parser_t * args, 
    423                     ct_tlv_builder_t * resp) 
     422static int do_memory_write(ifd_reader_t * reader, int unit, 
     423                           ct_tlv_parser_t * args, ct_tlv_builder_t * resp) 
    424424{ 
    425425        unsigned char *data; 
    … …  
    442442} 
    443443 
    444 static int do_memory_read(ifd_reader_t * reader, int unit, ct_tlv_parser_t * args, 
    445                   ct_tlv_builder_t * resp) 
     444static int do_memory_read(ifd_reader_t * reader, int unit, 
     445                          ct_tlv_parser_t * args, ct_tlv_builder_t * resp) 
    446446{ 
    447447        unsigned char data[CT_SOCKET_BUFSIZ]; 

  • trunk/src/ifd/proto-escape.c

    r960 r964  
    1919#include <string.h> 
    2020 
    21 static int 
    22 escape_init(ifd_protocol_t *prot) 
     21static int escape_init(ifd_protocol_t * prot) 
    2322{ 
    24         ifd_reader_t    *reader = prot->reader; 
     23        ifd_reader_t *reader = prot->reader; 
    2524        const ifd_driver_t *drv; 
    2625 
    2726        if (!reader || !(drv = reader->driver) 
    28          || !drv->ops || !drv->ops->escape) 
    29                 return -1; 
     27            || !drv->ops || !drv->ops->escape) 
     28                return -1; 
    3029        return 0; 
    3130} 
    3231 
    33 static void 
    34 escape_release(ifd_protocol_t *prot) 
     32static void escape_release(ifd_protocol_t * prot) 
    3533{ 
    3634        /* NOP */ 
    3735} 
    3836 
    39 static int 
    40 escape_set_param(ifd_protocol_t *prot, int type, long value) 
     37static int escape_set_param(ifd_protocol_t * prot, int type, long value) 
    4138{ 
    4239        ct_error("set_pameter not supported"); 
    … …  
    4441} 
    4542 
    46 static int 
    47 escape_get_param(ifd_protocol_t *prot, int type, long *result) 
     43static int escape_get_param(ifd_protocol_t * prot, int type, long *result) 
    4844{ 
    4945        ct_error("get_pameter not supported"); 
    … …  
    5248 
    5349static int 
    54 escape_transceive(ifd_protocol_t *prot, int dad, 
    55                 const void *sbuf, size_t slen, 
    56                 void *rbuf, size_t rlen) 
     50escape_transceive(ifd_protocol_t * prot, int dad, 
     51                  const void *sbuf, size_t slen, void *rbuf, size_t rlen) 
    5752{ 
    58         ifd_reader_t    *reader = prot->reader; 
     53        ifd_reader_t *reader = prot->reader; 
    5954        const ifd_driver_t *drv = reader->driver; 
    6055 
    … …  
    6257} 
    6358 
    64 struct ifd_protocol_ops ifd_protocol_esc = { 
    65         IFD_PROTOCOL_ESCAPE,            /* id */ 
    66         "escape",                       /* name */ 
    67         sizeof(ifd_protocol_t),         /* size */ 
    68         escape_init,                    /* init */ 
    69         escape_release,                 /* release */ 
    70         escape_set_param,               /* set_param */ 
    71         escape_get_param,               /* get_param */ 
    72         NULL,                           /* resynchronize */ 
    73         escape_transceive,              /* transceive */ 
    74         NULL,                           /* sync_read */ 
    75         NULL,                           /* sync_write */ 
     59struct ifd_protocol_ops ifd_protocol_esc = { 
     60        IFD_PROTOCOL_ESCAPE,    /* id */ 
     61        "escape",               /* name */ 
     62        sizeof(ifd_protocol_t), /* size */ 
     63        escape_init,            /* init */ 
     64        escape_release,         /* release */ 
     65        escape_set_param,       /* set_param */ 
     66        escape_get_param,       /* get_param */ 
     67        NULL,                   /* resynchronize */ 
     68        escape_transceive,      /* transceive */ 
     69        NULL,                   /* sync_read */ 
     70        NULL,                   /* sync_write */ 
    7671}; 
    77  

  • trunk/src/ifd/proto-gbp.c

    r950 r964  
    342342 
    343343static unsigned int gbp_build(gbp_state_t * gp, unsigned char *block, 
    344                        unsigned char pcb, ct_buf_t * bp) 
     344                              unsigned char pcb, ct_buf_t * bp) 
    345345{ 
    346346        unsigned int len; 
    … …  
    389389 */ 
    390390static unsigned int gbp_compute_checksum(gbp_state_t * gp, unsigned char *data, 
    391                                   size_t len) 
     391                                        size_t len) 
    392392{ 
    393393        csum_lrc_compute(data, len, data + len); 
    … …  
    395395} 
    396396 
    397 static int gbp_verify_checksum(gbp_state_t * gp, unsigned char *rbuf, size_t len) 
     397static int gbp_verify_checksum(gbp_state_t * gp, unsigned char *rbuf, 
     398                               size_t len) 
    398399{ 
    399400        unsigned char csum; 
    … …  
    406407 * Send/receive block 
    407408 */ 
    408 static int gbp_xcv(gbp_state_t * gp, unsigned char *block, size_t slen, size_t rmax) 
     409static int gbp_xcv(gbp_state_t * gp, unsigned char *block, size_t slen, 
     410                   size_t rmax) 
    409411{ 
    410412        ifd_protocol_t *prot = &gp->base; 

  • trunk/src/ifd/proto-t0.c

    r950 r964  
    305305} 
    306306 
    307 static int t0_recv(ifd_protocol_t * prot, ct_buf_t * bp, int count, long timeout) 
     307static int t0_recv(ifd_protocol_t * prot, ct_buf_t * bp, int count, 
     308                   long timeout) 
    308309{ 
    309310        int n; 

  • trunk/src/ifd/proto-t1.c

    r950 r964  
    441441 
    442442static unsigned int t1_build(t1_state_t * t1, unsigned char *block, 
    443          unsigned char dad, unsigned char pcb, ct_buf_t * bp, size_t * lenp) 
     443                             unsigned char dad, unsigned char pcb, 
     444                             ct_buf_t * bp, size_t * lenp) 
    444445{ 
    445446        unsigned int len; 
    … …  
    494495 */ 
    495496static unsigned int t1_compute_checksum(t1_state_t * t1, unsigned char *data, 
    496                                  size_t len) 
     497                                        size_t len) 
    497498{ 
    498499        return len + t1->checksum(data, len, data + len); 
    … …  
    520521 * Send/receive block 
    521522 */ 
    522 static int t1_xcv(t1_state_t * t1, unsigned char *block, size_t slen, size_t rmax) 
     523static int t1_xcv(t1_state_t * t1, unsigned char *block, size_t slen, 
     524                  size_t rmax) 
    523525{ 
    524526        ifd_protocol_t *prot = &t1->base; 

  • trunk/src/ifd/reader.c

    r950 r964  
    342342 
    343343static int ifd_recv_atr(ifd_device_t * dev, ct_buf_t * bp, unsigned int count, 
    344                  int revert_bits) 
     344                        int revert_bits) 
    345345{ 
    346346        unsigned char *buf; 

  • trunk/src/ifd/ria-device.c

    r951 r964  
    9696 
    9797static int ria_devsock_process(ct_socket_t * sock, header_t * hdr, 
    98                         ct_buf_t * args, ct_buf_t * resp) 
     98                               ct_buf_t * args, ct_buf_t * resp) 
    9999{ 
    100100        ria_client_t *ria = (ria_client_t *) sock->user_data; 

  • trunk/src/ifd/ria-server.c

    r957 r964  
    126126 */ 
    127127static int ria_svc_app_handler(ct_socket_t * sock, header_t * hdr, 
    128                         ct_buf_t * args, ct_buf_t * resp) 
     128                               ct_buf_t * args, ct_buf_t * resp) 
    129129{ 
    130130        unsigned char cmd; 
    … …  
    197197 */ 
    198198static int ria_svc_dev_handler(ct_socket_t * sock, header_t * hdr, 
    199                         ct_buf_t * args, ct_buf_t * resp) 
     199                               ct_buf_t * args, ct_buf_t * resp) 
    200200{ 
    201201        unsigned char cmd; 

  • trunk/src/ifd/ria.c

    r950 r964  
    4040        int rc; 
    4141 
    42         if (! address) { 
    43                 return NULL; 
    44         } 
    45  
    46         if (! ct_format_path(path, PATH_MAX, address)) { 
     42        if (!address) { 
     43                return NULL; 
     44        } 
     45 
     46        if (!ct_format_path(path, PATH_MAX, address)) { 
    4747                return NULL; 
    4848        } 
    … …  
    101101 
    102102static int ria_recv(ria_client_t * clnt, unsigned char expect, uint32_t xid, 
    103              void *res_buf, size_t res_len, long timeout) 
     103                    void *res_buf, size_t res_len, long timeout) 
    104104{ 
    105105        ct_socket_t *sock = clnt->sock; 
    … …  
    186186} 
    187187 
    188 static int ria_claim_device(ria_client_t * clnt, const char *name, ria_device_t * info) 
     188static int ria_claim_device(ria_client_t * clnt, const char *name, 
     189                            ria_device_t * info) 
    189190{ 
    190191        return ria_command(clnt, RIA_MGR_CLAIM, name, strlen(name), 

  • trunk/src/ifd/sys-bsd.c

    r941 r964  
    313313int ifd_sysdep_usb_open(const char *device) 
    314314{ 
    315         return open(device, O_RDWR); 
     315        return open(device, O_RDWR); 
    316316} 
    317317 
    … …  
    378378 
    379379                        /* FIXME: if we don't find a driver with vendor/product 
    380                          * then check for the interface type (ccid) and use 
    381                          * driver ccid... */ 
     380                         * then check for the interface type (ccid) and use 
     381                         * driver ccid... */ 
    382382 
    383383                        if (!(driver = ifd_driver_for_id(&id))) 
    … …  
    385385#ifdef __OpenBSD__ 
    386386                        snprintf(typedev, sizeof(typedev), 
    387                                 "usb:/dev/%s.00", device_info.udi_devnames[0]); 
     387                                 "usb:/dev/%s.00", device_info.udi_devnames[0]); 
    388388#else 
    389389                        snprintf(typedev, sizeof(typedev), 
    390390                                 "usb:/dev/%s", device_info.udi_devnames[0]); 
    391 #endif  /* __OpenBSD__ */ 
     391#endif                          /* __OpenBSD__ */ 
    392392 
    393393                        ifd_spawn_handler(driver, typedev, -1); 

  • trunk/src/ifd/sys-solaris.c

    r941 r964  
    186186} 
    187187 
    188 void 
    189 close_ep(int interface, int endpoint, int direction) 
     188void close_ep(int interface, int endpoint, int direction) 
    190189{ 
    191190        if (interfaces[interface][endpoint].ep_fd[direction]) { 
    … …  
    502501int ifd_sysdep_usb_open(const char *device) 
    503502{ 
    504         return open(device, O_RDWR); 
     503        return open(device, O_RDWR); 
    505504} 
    506505 
    … …  
    508507{ 
    509508        /* not implemented so far */ 
    510         return -1; 
     509        return -1; 
    511510} 
    512511 
    … …  
    553552 
    554553                /* FIXME: if we don't find a driver with vendor/product 
    555                  * then check for the interface type (ccid) and use 
    556                  * driver ccid... */ 
     554                 * then check for the interface type (ccid) and use 
     555                 * driver ccid... */ 
    557556 
    558557                if (!(driver = ifd_driver_for_id(&id))) 
    … …  
    592591                                          "ifd_scan_usb: \t\tfound device instance %s\n", 
    593592                                          device_instance_cntrl0_name); 
    594                                 snprintf(typedev,sizeof(typedev), 
    595                                         "usb:%s", device_instance_cntrl0_name); 
     593                                snprintf(typedev, sizeof(typedev), 
     594                                         "usb:%s", device_instance_cntrl0_name); 
    596595                                ifd_spawn_handler(driver, typedev, -1); 
    597596                        } 

  • trunk/src/ifd/sys-sunray.c

    r941 r964  
    300300{ 
    301301        /* not implemented so far */ 
    302         return -1; 
     302        return -1; 
    303303} 
    304304 
    … …  
    327327 
    328328                        /* FIXME: if we don't find a driver with vendor/product 
    329                          * then check for the interface type (ccid) and use 
    330                          * driver ccid... */ 
     329                         * then check for the interface type (ccid) and use 
     330                         * driver ccid... */ 
    331331 
    332332                        if (!(driver = ifd_driver_for_id(&id))) 

  • trunk/src/ifd/usb-descriptors.c

    r950 r964  
    6868                        break; 
    6969 
    70                 ct_debug("in p_ep: skipping descriptor 0x%X", header->bDescriptorType); 
     70                ct_debug("in p_ep: skipping descriptor 0x%X", 
     71                         header->bDescriptorType); 
    7172                numskipped++; 
    7273 
    … …  
    220221                                return retval; 
    221222 
    222                         if ( ifp->endpoint[i].extra != NULL ) { 
    223                                 ifp->extra = (unsigned char *)malloc(ifp->endpoint[i].extralen); 
     223                        if (ifp->endpoint[i].extra != NULL) { 
     224                                ifp->extra = 
     225                                    (unsigned char *)malloc(ifp->endpoint[i]. 
     226                                                            extralen); 
    224227                                if (!ifp->extra) { 
    225228                                        ct_error("out of memory"); 
    … …  
    228231                                } 
    229232                                memcpy(ifp->extra, ifp->endpoint[i].extra, 
    230                                         ifp->endpoint[i].extralen); 
     233                                       ifp->endpoint[i].extralen); 
    231234                                ifp->extralen = ifp->endpoint[i].extralen; 
    232235                        } 
    … …  
    249252 
    250253static int ifd_usb_parse_configuration(struct ifd_usb_config_descriptor *config, 
    251                                 unsigned char *buffer) 
     254                                       unsigned char *buffer) 
    252255{ 
    253256        int i, retval, size; 
    … …  
    427430                        if (as->extra) { 
    428431                                free(as->extra); 
    429                                 as->extra=NULL; 
     432                                as->extra = NULL; 
    430433                        } 
    431434 
    … …  
    436439                                if (as->endpoint[k].extra) { 
    437440                                        free(as->endpoint[k].extra); 
    438                                         as->endpoint[k].extra=NULL; 
     441                                        as->endpoint[k].extra = NULL; 
    439442                                } 
    440443                        } 
    441444                        free(as->endpoint); 
    442                         as->endpoint=NULL; 
     445                        as->endpoint = NULL; 
    443446                } 
    444447 
    445448                free(ifp->altsetting); 
    446                 ifp->altsetting=NULL; 
     449                ifp->altsetting = NULL; 
    447450        } 
    448451 
    449452        free(cf->interface); 
    450         cf->interface=NULL; 
    451 } 
     453        cf->interface = NULL; 
     454} 

  • trunk/src/ifd/usb.c

    r926 r964  
    171171        int rc; 
    172172 
    173         rc = ifd_sysdep_usb_reset( dev ); 
     173        rc = ifd_sysdep_usb_reset(dev); 
    174174 
    175175        return rc; 
    176176} 
    177  
    178  
    179177 
    180178static struct ifd_device_ops ifd_usb_ops; 
    … …  
    192190                return NULL; 
    193191        } 
    194          
     192 
    195193        ifd_usb_ops.poll_presence = ifd_sysdep_usb_poll_presence; 
    196194        ifd_usb_ops.set_params = usb_set_params; 

  • trunk/src/ifd/utils.c

    r904 r964  
    126126 
    127127        type = strdup(devtype); 
    128         device = strtok(type,":"); 
    129         device = strtok(NULL,":"); 
     128        device = strtok(type, ":"); 
     129        device = strtok(NULL, ":"); 
    130130        if (!device || !type) { 
    131                 ct_error("failed to parse devtype %s",devtype); 
     131                ct_error("failed to parse devtype %s", devtype); 
    132132                exit(1); 
    133133        } 
Note: See TracChangeset for help on using the changeset viewer.