Changeset 3394


Ignore:
Timestamp:
11/12/07 10:42:38 (6 years ago)
Author:
tick
Message:

gsmd: cleaning some dummy codes (Tick)

Location:
trunk/src/target/gsm
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/target/gsm/include/libgsmd/phonebook.h

    r3309 r3394  
    4949        char findtext[LGSM_PB_TEXT_MAXLEN+1]; 
    5050}; 
    51  
    52 #if 0 
    53 /* Get a bitmask of supported phonebook types */ 
    54 extern int lgsm_pb_get_types(struct lgsm_handle *lh, u_int32 *typemask); 
    55  
    56 /* Get a range of supported indexes in given phonebook type, Chapter 8.12 */ 
    57 extern int lgsm_pb_get_range(struct lgsm_handle *lh, 
    58                              enum lgsm_pbook_type type, 
    59                              u_int32_t *from, u_int32_t *to, 
    60                              u_int32_t *nlength, *u_int32_t tlength); 
    61  
    62 #define LGSM_PB_TEXT_MAXLEN     31 
    63 #endif 
    6451 
    6552struct lgsm_pb_entry { 

  • trunk/src/target/gsm/src/gsmd/usock.c

    r3309 r3394  
    672672} 
    673673 
    674 #if 0 
    675 static int sms_list_cb(struct gsmd_atcmd *cmd, void *ctx, char *resp) 
    676 { 
    677         struct gsmd_user *gu = ctx; 
    678         struct gsmd_ucmd *ucmd; 
    679         struct gsmd_sms_list msg; 
    680         int i, idx, stat, len, cr; 
    681         u_int8_t pdu[180]; 
    682  
    683         if (cmd->ret && cmd->ret != -255) 
    684                 return 0; 
    685  
    686         /* FIXME: TEXT mode */ 
    687         if ( 
    688                         sscanf(resp, "+CMGL: %i,%i,,%i\n%n", 
    689                                 &idx, &stat, &len, &cr) < 3 && 
    690                         sscanf(resp, "+CMGL: %i,%i,\"%*[^\"]\",%i\n%n", 
    691                                 &idx, &stat, &len, &cr) < 3) 
    692                 return -EINVAL; 
    693         if (len > 164) 
    694                 return -EINVAL; 
    695  
    696         msg.index = idx; 
    697         msg.stat = stat; 
    698         msg.is_last = (cmd->ret == 0); 
    699         for (i = 0; resp[cr] >= '0' && resp[cr + 1] >= '0' && i < 180; i ++) { 
    700                 if (sscanf(resp + cr, "%2hhX", &pdu[i]) < 1) { 
    701                         gsmd_log(GSMD_DEBUG, "malformed input (%i)\n", i); 
    702                         return -EINVAL; 
    703                 } 
    704                 cr += 2; 
    705         } 
    706         if (sms_pdu_to_msg(&msg, pdu, len, i)) { 
    707                 gsmd_log(GSMD_DEBUG, "malformed PDU\n"); 
    708                 return -EINVAL; 
    709         } 
    710  
    711         ucmd = gsmd_ucmd_fill(sizeof(msg), GSMD_MSG_SMS, 
    712                               GSMD_SMS_LIST, cmd->id); 
    713         if (!ucmd) 
    714                 return -ENOMEM; 
    715         memcpy(ucmd->buf, &msg, sizeof(msg)); 
    716  
    717         usock_cmd_enqueue(ucmd, gu); 
    718  
    719         return 0; 
    720 } 
    721  
    722 static int sms_read_cb(struct gsmd_atcmd *cmd, void *ctx, char *resp) 
    723 { 
    724         struct gsmd_user *gu = ctx; 
    725         struct gsmd_ucmd *ucmd; 
    726         struct gsmd_sms_list msg; 
    727         int i, stat, len, cr; 
    728         u_int8_t pdu[180]; 
    729  
    730         if (cmd->ret) 
    731                 return 0; 
    732  
    733         /* FIXME: TEXT mode */ 
    734         if ( 
    735                         sscanf(resp, "+CMGR: %i,,%i\n%n", 
    736                                 &stat, &len, &cr) < 2 && 
    737                         sscanf(resp, "+CMGR: %i,%*i,%i\n%n", 
    738                                 &stat, &len, &cr) < 2) 
    739                 return -EINVAL; 
    740         if (len > 164) 
    741                 return -EINVAL; 
    742  
    743         msg.index = 0; 
    744         msg.stat = stat; 
    745         msg.is_last = 1; 
    746         for (i = 0; resp[cr] >= '0' && resp[cr + 1] >= '0' && i < 180; i ++) { 
    747                 if (sscanf(resp + cr, "%2hhX", &pdu[i]) < 1) { 
    748                         gsmd_log(GSMD_DEBUG, "malformed input (%i)\n", i); 
    749                         return -EINVAL; 
    750                 } 
    751                 cr += 2; 
    752         } 
    753         if (sms_pdu_to_msg(&msg, pdu, len, i)) { 
    754                 gsmd_log(GSMD_DEBUG, "malformed PDU\n"); 
    755                 return -EINVAL; 
    756         } 
    757  
    758         ucmd = gsmd_ucmd_fill(sizeof(msg), GSMD_MSG_SMS, 
    759                               GSMD_SMS_READ, cmd->id); 
    760         if (!ucmd) 
    761                 return -ENOMEM; 
    762         memcpy(ucmd->buf, &msg, sizeof(msg)); 
    763  
    764         usock_cmd_enqueue(ucmd, gu); 
    765  
    766         return 0; 
    767 } 
    768  
    769 static int sms_send_cb(struct gsmd_atcmd *cmd, void *ctx, char *resp) 
    770 { 
    771         struct gsmd_user *gu = ctx; 
    772         struct gsmd_ucmd *ucmd; 
    773         int msgref; 
    774  
    775         if (cmd->ret == 0 || cmd->ret == -255) { 
    776                 if (sscanf(resp, "+CMGS: %i", &msgref) < 1) 
    777                         return -EINVAL; 
    778         } else 
    779                 msgref = -cmd->ret; 
    780  
    781         ucmd = gsmd_ucmd_fill(sizeof(int), GSMD_MSG_SMS, 
    782                         GSMD_SMS_SEND, cmd->id); 
    783         if (!ucmd) 
    784                 return -ENOMEM; 
    785         *(int *) ucmd->buf = msgref; 
    786  
    787         usock_cmd_enqueue(ucmd, gu); 
    788  
    789         return 0; 
    790 } 
    791  
    792 static int sms_write_cb(struct gsmd_atcmd *cmd, void *ctx, char *resp) 
    793 { 
    794         struct gsmd_user *gu = ctx; 
    795         struct gsmd_ucmd *ucmd; 
    796         int result; 
    797  
    798         if (cmd->ret == 0) { 
    799                 if (sscanf(resp, "+CMGW: %i", &result) < 1) 
    800                         return -EINVAL; 
    801         } else 
    802                 result = -cmd->ret; 
    803  
    804         ucmd = gsmd_ucmd_fill(sizeof(int), GSMD_MSG_SMS, 
    805                         GSMD_SMS_WRITE, cmd->id); 
    806         if (!ucmd) 
    807                 return -ENOMEM; 
    808         *(int *) ucmd->buf = result; 
    809  
    810         usock_cmd_enqueue(ucmd, gu); 
    811  
    812         return 0; 
    813 } 
    814  
    815 static int sms_delete_cb(struct gsmd_atcmd *cmd, void *ctx, char *resp) 
    816 { 
    817         struct gsmd_user *gu = ctx; 
    818         struct gsmd_ucmd *ucmd; 
    819         int *result; 
    820  
    821         ucmd = gsmd_ucmd_fill(sizeof(int), GSMD_MSG_SMS, 
    822                               GSMD_SMS_DELETE, cmd->id); 
    823         if (!ucmd) 
    824                 return -ENOMEM;  
    825  
    826         result = (int *) ucmd->buf; 
    827         *result = cmd->ret; 
    828  
    829         usock_cmd_enqueue(ucmd, gu); 
    830  
    831         return 0; 
    832 } 
    833  
    834 static int usock_cpms_cb(struct gsmd_atcmd *cmd, void *ctx, char *resp) 
    835 { 
    836         struct gsmd_user *gu = ctx; 
    837         struct gsmd_ucmd *ucmd = ucmd_alloc(sizeof(struct gsmd_sms_storage)); 
    838         struct gsmd_sms_storage *gss = (typeof(gss)) ucmd->buf; 
    839         char buf[3][3]; 
    840  
    841         DEBUGP("entering(cmd=%p, gu=%p)\n", cmd, gu); 
    842  
    843         if (!ucmd) 
    844                 return -ENOMEM; 
    845  
    846         ucmd->hdr.version = GSMD_PROTO_VERSION; 
    847         ucmd->hdr.msg_type = GSMD_MSG_SMS; 
    848         ucmd->hdr.msg_subtype = GSMD_SMS_GET_MSG_STORAGE; 
    849         ucmd->hdr.len = sizeof(struct gsmd_sms_storage); 
    850         ucmd->hdr.id = cmd->id; 
    851  
    852         if (sscanf(resp, "+CPMS: \"%2[A-Z]\",%hi,%hi," 
    853                                 "\"%2[A-Z]\",%hi,%hi,\"%2[A-Z]\",%hi,%hi", 
    854                                 buf[0], &gss->mem[0].used, &gss->mem[0].total, 
    855                                 buf[1], &gss->mem[1].used, &gss->mem[1].total, 
    856                                 buf[2], &gss->mem[2].used, &gss->mem[2].total) 
    857                         < 9) { 
    858                 talloc_free(ucmd); 
    859                 return -EINVAL; 
    860         } 
    861  
    862         gss->mem[0].memtype = parse_memtype(buf[0]); 
    863         gss->mem[1].memtype = parse_memtype(buf[1]); 
    864         gss->mem[2].memtype = parse_memtype(buf[2]); 
    865  
    866         usock_cmd_enqueue(ucmd, gu); 
    867  
    868         return 0; 
    869 } 
    870  
    871 static int usock_get_smsc_cb(struct gsmd_atcmd *cmd, void *ctx, char *resp) 
    872 { 
    873         struct gsmd_user *gu = ctx; 
    874         struct gsmd_ucmd *ucmd; 
    875         struct gsmd_addr *ga; 
    876  
    877         ucmd = gsmd_ucmd_fill(sizeof(struct gsmd_addr), GSMD_MSG_SMS, 
    878                         GSMD_SMS_GET_SERVICE_CENTRE, cmd->id); 
    879         if (!ucmd) 
    880                 return -ENOMEM; 
    881  
    882         ga = (struct gsmd_addr *) ucmd->buf; 
    883         if (sscanf(resp, "+CSCA: \"%31[^\"]\",%hhi", 
    884                                 ga->number, &ga->type) < 2) { 
    885                 talloc_free(ucmd); 
    886                 return -EINVAL; 
    887         } 
    888  
    889         usock_cmd_enqueue(ucmd, gu); 
    890         return 0; 
    891 } 
    892  
    893 static const char *gsmd_cmgl_stat[] = { 
    894         "REC UNREAD", "REC READ", "STO UNSENT", "STO SENT", "ALL", 
    895 }; 
    896  
    897 static int usock_rcv_sms(struct gsmd_user *gu, struct gsmd_msg_hdr *gph,  
    898                          int len) 
    899 { 
    900         /* FIXME: TEXT mode support!!  */ 
    901         struct gsmd_atcmd *cmd = NULL; 
    902         struct gsmd_sms_delete *gsd; 
    903         struct gsmd_sms_submit *gss; 
    904         struct gsmd_sms_write *gsw; 
    905         struct gsmd_addr *ga; 
    906         enum ts0705_mem_type *storage; 
    907         int *stat, *index; 
    908         int atcmd_len; 
    909         char buf[1024]; 
    910  
    911         switch (gph->msg_subtype) { 
    912         case GSMD_SMS_LIST: 
    913                 if(len < sizeof(*gph) + sizeof(int)) 
    914                         return -EINVAL; 
    915                 stat = (int *) ((void *)gph + sizeof(*gph)); 
    916                 if (*stat < 0 || *stat > 4) 
    917                         return -EINVAL; 
    918  
    919                 if (gu->gsmd->flags & GSMD_FLAG_SMS_FMT_TEXT) 
    920                         atcmd_len = sprintf(buf, "AT+CMGL=\"%s\"", 
    921                                         gsmd_cmgl_stat[*stat]); 
    922                 else 
    923                         atcmd_len = sprintf(buf, "AT+CMGL=%i", *stat); 
    924  
    925                 cmd = atcmd_fill(buf, atcmd_len + 1, 
    926                                 &sms_list_cb, gu, gph->id); 
    927                 break; 
    928  
    929         case GSMD_SMS_READ: 
    930                 if(len < sizeof(*gph) + sizeof(int)) 
    931                         return -EINVAL; 
    932                 index = (int *) ((void *)gph + sizeof(*gph)); 
    933  
    934                 atcmd_len = sprintf(buf, "AT+CMGR=%i", *index); 
    935  
    936                 cmd = atcmd_fill(buf, atcmd_len + 1, 
    937                                  &sms_read_cb, gu, gph->id); 
    938                 break; 
    939  
    940         case GSMD_SMS_SEND: 
    941                 if (len < sizeof(*gph) + sizeof(*gss)) 
    942                         return -EINVAL; 
    943                 gss = (struct gsmd_sms_submit *) ((void *) gph + sizeof(*gph)); 
    944  
    945                 if (gu->gsmd->flags & GSMD_FLAG_SMS_FMT_TEXT) { 
    946                         atcmd_len = sprintf(buf, "AT+CMGS=\"%s\"\n%.*s", 
    947                                         gss->addr.number, 
    948                                         gss->payload.length, 
    949                                         gss->payload.data);     /* FIXME */ 
    950                 } else { 
    951                         atcmd_len = sprintf(buf, "AT+CMGS=%i\n", 
    952                                         sms_pdu_make_smssubmit(NULL, gss) - 1); 
    953                         atcmd_len += sms_pdu_make_smssubmit(buf + atcmd_len, 
    954                                         gss) * 2; 
    955                 } 
    956                 buf[atcmd_len ++] = 26; /* ^Z ends the message */ 
    957                 buf[atcmd_len ++] = 0; 
    958  
    959                 cmd = atcmd_fill(buf, atcmd_len, &sms_send_cb, gu, gph->id); 
    960                 break; 
    961  
    962         case GSMD_SMS_WRITE: 
    963                 if (len < sizeof(*gph) + sizeof(*gsw)) 
    964                         return -EINVAL; 
    965                 gsw = (struct gsmd_sms_write *) ((void *) gph + sizeof(*gph)); 
    966                 if (gsw->stat > 4) 
    967                         return -EINVAL; 
    968  
    969                 if (gu->gsmd->flags & GSMD_FLAG_SMS_FMT_TEXT) { 
    970                         atcmd_len = sprintf(buf, "AT+CMGW=\"%s\"\n%.*s", 
    971                                         gsw->sms.addr.number, 
    972                                         gsw->sms.payload.length, 
    973                                         gsw->sms.payload.data); /* FIXME */ 
    974                 } else { 
    975                         atcmd_len = sprintf(buf, "AT+CMGW=%i,%i\n", 
    976                                         sms_pdu_make_smssubmit(NULL, 
    977                                                 &gsw->sms) - 1, gsw->stat); 
    978                         atcmd_len += sms_pdu_make_smssubmit(buf + atcmd_len, 
    979                                         &gsw->sms) * 2; 
    980                 } 
    981                 buf[atcmd_len ++] = 26; /* ^Z ends the message */ 
    982                 buf[atcmd_len ++] = 0; 
    983  
    984                 cmd = atcmd_fill(buf, atcmd_len, &sms_write_cb, gu, gph->id); 
    985                 break; 
    986  
    987         case GSMD_SMS_DELETE: 
    988                 if(len < sizeof(*gph) + sizeof(*gsd)) 
    989                         return -EINVAL; 
    990                 gsd = (struct gsmd_sms_delete *) ((void *)gph + sizeof(*gph)); 
    991  
    992                 atcmd_len = sprintf(buf, "AT+CMGD=%d,%d", 
    993                                 gsd->index, gsd->delflg); 
    994  
    995                 cmd = atcmd_fill(buf, atcmd_len + 1, 
    996                                 &sms_delete_cb, gu, gph->id); 
    997                 break; 
    998  
    999         case GSMD_SMS_GET_MSG_STORAGE: 
    1000                 cmd = atcmd_fill("AT+CPMS?", 8 + 1, usock_cpms_cb, gu, 0); 
    1001                 break; 
    1002  
    1003         case GSMD_SMS_SET_MSG_STORAGE: 
    1004                 if (len < sizeof(*gph) + 3 * sizeof(enum ts0705_mem_type)) 
    1005                         return -EINVAL; 
    1006                 storage = (enum ts0705_mem_type *) 
    1007                         ((void *) gph + sizeof(*gph)); 
    1008                 atcmd_len = sprintf(buf, "AT+CPMS=\"%s\",\"%s\",\"%s\"", 
    1009                                 ts0705_memtype_name[storage[0]], 
    1010                                 ts0705_memtype_name[storage[1]], 
    1011                                 ts0705_memtype_name[storage[2]]); 
    1012                 cmd = atcmd_fill(buf, atcmd_len + 1, 
    1013                                 &null_cmd_cb, gu, gph->id); 
    1014                 break;   
    1015  
    1016         case GSMD_SMS_GET_SERVICE_CENTRE: 
    1017                 cmd = atcmd_fill("AT+CSCA?", 8 + 1, &usock_get_smsc_cb, gu, 0); 
    1018                 break; 
    1019  
    1020         case GSMD_SMS_SET_SERVICE_CENTRE: 
    1021                 if (len < sizeof(*gph) + sizeof(struct gsmd_addr)) 
    1022                         return -EINVAL; 
    1023                 ga = (struct gsmd_addr *) ((void *) gph + sizeof(*gph)); 
    1024                 atcmd_len = sprintf(buf, "AT+CSCA=\"%s\",%i", 
    1025                                 ga->number, ga->type); 
    1026                 cmd = atcmd_fill(buf, atcmd_len + 1, 
    1027                                 &null_cmd_cb, gu, gph->id); 
    1028                 break; 
    1029  
    1030         default: 
    1031                 return -EINVAL; 
    1032         } 
    1033  
    1034         if (!cmd) 
    1035                 return -ENOMEM; 
    1036  
    1037         gsmd_log(GSMD_DEBUG, "%s\n", cmd ? cmd->buf : 0); 
    1038         return atcmd_submit(gu->gsmd, cmd); 
    1039 } 
    1040 #endif 
    1041  
    1042674static int phonebook_find_cb(struct gsmd_atcmd *cmd, void *ctx, char *resp) 
    1043675{ 

  • trunk/src/target/gsm/src/gsmd/vendor_ti.c

    r3268 r3394  
    3737#include <gsmd/vendorplugin.h> 
    3838#include <gsmd/unsolicited.h> 
    39  
    40 #if 0 
    41 #include "vendorplugin.h" 
    42  
    43 static int  
    44 ti_getopt(struct gsmd *gh, int optname, void *optval, int *optlen) 
    45 { 
    46         switch (optname) { 
    47         case GSMD_OPT_CIPHER_IND: 
    48                 /* FIXME: send AT%CPRI=? */ 
    49                 break; 
    50         default: 
    51                 return -EINVAL; 
    52         } 
    53 } 
    54  
    55 static int  
    56 ti_setopt(struct gsmd *gh, int optname, const void *optval, int optlen) 
    57 { 
    58         switch (optname) { 
    59         case GSMD_OPT_CIPHER_IND: 
    60                 /* FIXME: send AT%CPRI= */ 
    61                 break; 
    62         default: 
    63                 return -EINVAL; 
    64         } 
    65 } 
    66  
    67 #endif 
    6839 
    6940 

  • trunk/src/target/gsm/src/gsmd/vendor_tihtc.c

    r2730 r3394  
    5252        return atcmd_submit(gsmd, cmd); 
    5353} 
    54  
    55  
    56 #if 0 
    57 #include "vendorplugin.h" 
    58  
    59 static int 
    60 ti_getopt(struct gsmd *gh, int optname, void *optval, int *optlen) 
    61 { 
    62         switch (optname) { 
    63         case GSMD_OPT_CIPHER_IND: 
    64                 /* FIXME: send AT%CPRI=? */ 
    65                 break; 
    66         default: 
    67                 return -EINVAL; 
    68         } 
    69 } 
    70  
    71 static int 
    72 ti_setopt(struct gsmd *gh, int optname, const void *optval, int optlen) 
    73 { 
    74         switch (optname) { 
    75         case GSMD_OPT_CIPHER_IND: 
    76                 /* FIXME: send AT%CPRI= */ 
    77                 break; 
    78         default: 
    79                 return -EINVAL; 
    80         } 
    81 } 
    82  
    83 #endif 
    84  
    8554 
    8655static int htccsq_parse(char *buf, int len, const char *param, 

  • trunk/src/target/gsm/src/util/atcmd.c

    r2957 r3394  
    4848        lgsm_register_handler(lgsmh, GSMD_MSG_PASSTHROUGH, &pt_msghandler); 
    4949 
    50 #if 1 
    5150        fcntl(0, F_SETFD, O_NONBLOCK); 
    5251        fcntl(1, F_SETFD, O_NONBLOCK); 
    5352        fcntl(2, F_SETFD, O_NONBLOCK); 
    5453        fcntl(lgsm_fd(lgsmh), F_SETFD, O_NONBLOCK); 
    55 #endif 
    5654 
    5755        FD_ZERO(&readset); 
Note: See TracChangeset for help on using the changeset viewer.