开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 手机WAP编程 > 查看源码
bb_smscconn.c
资源名称：gateway-1.2.1　[点击查看]
上传用户：gzpyjq
上传日期：2013-01-31
资源大小：1852k
文件大小：19k
源码类别：

手机WAP编程

开发平台：

WINDOWS

bb_smscconn.c：源码内容
  1. /*
  2.  * SMSC Connection interface for Bearerbox.
  3.  *
  4.  * Includes callback functions called by SMSCConn implementations
  5.  *
  6.  * Handles all startup/shutdown adminstrative work in bearerbox, plus
  7.  * routing, writing actual access logs, handling failed messages etc.
  8.  *
  9.  * Kalle Marjola 2000 for project Kannel
  10.  */
  12. #include <errno.h>
  13. #include <stdlib.h>
  14. #include <stdio.h>
  15. #include <time.h>
  16. #include <string.h>
  17. #include <sys/time.h>
  18. #include <sys/types.h>
  19. #include <unistd.h>
  20. #include <signal.h>
  21. #include <fcntl.h>
  24. #include "gwlib/gwlib.h"
  25. #include "msg.h"
  26. #include "sms.h"
  27. #include "bearerbox.h"
  28. #include "numhash.h"
  29. #include "smscconn.h"
  31. #include "bb_smscconn_cb.h"    /* callback functions for connections */
  32. #include "smscconn_p.h"        /* to access counters */
  34. /* passed from bearerbox core */
  36. extern volatile sig_atomic_t bb_status;
  37. extern List *incoming_wdp;
  38. extern List *incoming_sms;
  39. extern List *outgoing_sms;
  41. extern Counter *incoming_sms_counter;
  42. extern Counter *outgoing_sms_counter;
  44. extern List *flow_threads;
  45. extern List *suspended;
  46. extern List *isolated;
  48. /* our own thingies */
  50. static volatile sig_atomic_t smsc_running;
  51. static List *smsc_list;
  52. static List *smsc_groups;
  53. static Octstr *unified_prefix;
  55. static Numhash *black_list;
  56. static Numhash *white_list;
  58. static long maximum_queue_length;
  60. static long router_thread = -1;
  62. static void log_sms(SMSCConn *conn, Msg *sms, char *message)
  63. {
  64.     Octstr *text, *udh;
  65.     
  66.     text = sms->sms.msgdata ? octstr_duplicate(sms->sms.msgdata) : octstr_create("");
  67.     udh = sms->sms.udhdata ? octstr_duplicate(sms->sms.udhdata) : octstr_create("");
  68.     if ((sms->sms.coding == DC_8BIT || sms->sms.coding == DC_UCS2))
  69. octstr_binary_to_hex(text, 1);
  70.     octstr_binary_to_hex(udh, 1);
  72.     alog("%s [SMSC:%s] [SVC:%s] [ACT:%s] [from:%s] [to:%s] [flags:%d:%d:%d:%d:%d] [msg:%d:%s]"
  73. " [udh:%d:%s]",
  74.  message,
  75.  conn ? (smscconn_id(conn) ? octstr_get_cstr(smscconn_id(conn)) : "")
  76.  : "",
  77.  sms->sms.service ? octstr_get_cstr(sms->sms.service) : "",
  78.  sms->sms.account ? octstr_get_cstr(sms->sms.account) : "",
  79.  sms->sms.sender ? octstr_get_cstr(sms->sms.sender) : "",
  80.  sms->sms.receiver ? octstr_get_cstr(sms->sms.receiver) : "",
  81.  sms->sms.mclass, sms->sms.coding, sms->sms.mwi, sms->sms.compress,
  82.  sms->sms.dlr_mask,
  83.  octstr_len(sms->sms.msgdata), octstr_get_cstr(text),
  84.  octstr_len(sms->sms.udhdata), octstr_get_cstr(udh)
  85.     );
  86.     octstr_destroy(udh);
  87.     octstr_destroy(text);
  88. }
  90. /*---------------------------------------------------------------------------
  91.  * CALLBACK FUNCTIONS
  92.  *
  93.  * called by SMSCConn implementations when appropriate
  94.  */
  96. void bb_smscconn_ready(SMSCConn *conn)
  97. {
  98.     list_add_producer(flow_threads);
  99.     list_add_producer(incoming_sms);
  100. }
  103. void bb_smscconn_connected(SMSCConn *conn)
  104. {
  105.     if (router_thread >= 0)
  106. gwthread_wakeup(router_thread);
  107. }
  110. void bb_smscconn_killed(void)
  111. {
  112.     /* NOTE: after status has been set to SMSCCONN_DEAD, bearerbox
  113.      *   is free to release/delete 'conn'
  114.      */
  115.     list_remove_producer(incoming_sms);
  116.     list_remove_producer(flow_threads);
  117. }
  120. void bb_smscconn_sent(SMSCConn *conn, Msg *sms)
  121. {
  122.     Msg *mack;
  123.     
  124.     counter_increase(outgoing_sms_counter);
  125.     if (conn) counter_increase(conn->sent);
  126.     
  127.     /* write ACK to store file */
  129.     mack = msg_create(ack);
  130.     mack->ack.nack = 0;
  131.     mack->ack.time = sms->sms.time;
  132.     mack->ack.id = sms->sms.id;
  133.     
  134.     (void) store_save(mack);
  135.     msg_destroy(mack);
  136.     
  137.     /* XXX relay confirmancy message should be generated here */
  138.     
  139.     log_sms(conn, sms, "Sent SMS");
  140.     msg_destroy(sms);
  141. }
  144. void bb_smscconn_send_failed(SMSCConn *conn, Msg *sms, int reason)
  145. {
  146.     Msg *mnack;
  147.     
  148.     switch (reason) {
  150.     case SMSCCONN_FAILED_SHUTDOWN:
  151.     case SMSCCONN_FAILED_TEMPORARILY:
  152. list_produce(outgoing_sms, sms);
  153. break;
  154.     default:
  156. /* write NACK to store file */
  158. mnack = msg_create(ack);
  159. mnack->ack.nack = 1;
  160. mnack->ack.time = sms->sms.time;
  161. mnack->ack.id = sms->sms.id;
  163. (void) store_save(mnack);
  164. msg_destroy(mnack);
  165.     
  166. if (conn) counter_increase(conn->failed);
  167. if (reason == SMSCCONN_FAILED_DISCARDED)
  168.     log_sms(conn, sms, "DISCARDED SMS");
  169. else
  170.     log_sms(conn, sms, "FAILED Send SMS");
  171. msg_destroy(sms);
  172.     } 
  173. }    
  175. int bb_smscconn_receive(SMSCConn *conn, Msg *sms)
  176. {
  177.     char *uf;
  179.     /* do some queue control */
  180.     if (maximum_queue_length != -1 && bb_status == BB_FULL && 
  181.             list_len(incoming_sms) <= maximum_queue_length) {
  182.         bb_status = BB_RUNNING;
  183.         warning(0, "started to accept messages again");
  184.     }
  185.     
  186.     if (maximum_queue_length != -1 && 
  187.             list_len(incoming_sms) > maximum_queue_length) {
  188.         if (bb_status != BB_FULL)
  189.             bb_status = BB_FULL;
  190.         warning(0, "incoming messages queue too long, dropping a message");
  191.         log_sms(conn, sms, "DROPPED Received SMS");
  192.         gwthread_sleep(0.1); /* letting the queue go down */
  193.       return -1;
  194.     }
  196.     /* else if (list_len(incoming_sms) > 100)
  197.      * gwthread_sleep(0.5);
  198.      */
  199.     
  200.     if (unified_prefix == NULL)
  201.      uf = NULL;
  202.     else
  203.      uf = octstr_get_cstr(unified_prefix);
  205.     normalize_number(uf, &(sms->sms.sender));
  207.     if (white_list &&
  208. numhash_find_number(white_list, sms->sms.sender) < 1) {
  209. info(0, "Number <%s> is not in white-list, message discarded",
  210.      octstr_get_cstr(sms->sms.sender));
  211. log_sms(conn, sms, "REJECTED - not white-listed SMS");
  212. msg_destroy(sms);
  213.         return -1;
  214.     }
  215.     if (black_list &&
  216. numhash_find_number(black_list, sms->sms.sender) == 1) {
  217. info(0, "Number <%s> is in black-list, message discarded",
  218.      octstr_get_cstr(sms->sms.sender));
  219. log_sms(conn, sms, "REJECTED - black-listed SMS");
  220. msg_destroy(sms);
  221. return -1;
  222.     }
  224.     if (sms->sms.sms_type != report)
  225. sms->sms.sms_type = mo;
  226.     
  227.     /* write to store (if enabled) */
  228.     if (store_save(sms) == -1)
  229. return -1;
  230.     
  231.     if (sms->sms.sms_type != report)
  232. log_sms(conn, sms, "Receive SMS");
  233.     else
  234. log_sms(conn, sms, "DLR SMS");
  236.     list_produce(incoming_sms, sms);
  237.     counter_increase(incoming_sms_counter);
  238.     counter_increase(conn->received);
  240.     return 0;
  241. }
  244. /*---------------------------------------------------------------------
  245.  * Other functions
  246.  */
  249.     
  250. /* function to route outgoing SMS'es from delay-list
  251.  * use some nice magics to route them to proper SMSC
  252.  */
  253. static void sms_router(void *arg)
  254. {
  255.     Msg *msg, *newmsg, *startmsg;
  256.     int ret;
  257.     
  258.     list_add_producer(flow_threads);
  259.     gwthread_wakeup(MAIN_THREAD_ID);
  261.     newmsg = startmsg = NULL;
  262.     ret = 0;
  263.     
  264.     while(bb_status != BB_DEAD) {
  266. if (newmsg == startmsg) {
  267.     if (ret != 1) {
  268. debug("bb.sms", 0, "sms_router: time to sleep"); 
  269. gwthread_sleep(600.0); /* hopefully someone wakes us up */
  270. debug("bb.sms", 0, "sms_router: list_len = %ld",
  271.       list_len(outgoing_sms));
  272.     }
  273.     startmsg = list_consume(outgoing_sms);
  274.     newmsg = NULL;
  275.     msg = startmsg;
  276. } else {
  277.     newmsg = list_consume(outgoing_sms);
  278.     msg = newmsg;
  279. }
  280. /* debug("bb.sms", 0, "sms_router: handling message (%p vs %p)",
  281.  *         newmsg, startmsg); */
  283. if (msg == NULL)
  284.             break;
  286. ret = smsc2_rout(msg);
  287. if (ret == -1) {
  288.             warning(0, "No SMSCes to receive message, discarding it!");
  289.     bb_smscconn_send_failed(NULL, msg, SMSCCONN_FAILED_DISCARDED);
  290.         } else if (ret == 1) {
  291.     newmsg = startmsg = NULL;
  292. }
  293.     
  294.     
  295.     }
  296.     /* router has died, make sure that rest die, too */
  297.     
  298.     smsc_running = 0;
  300.     list_remove_producer(flow_threads);
  301. }
  306. /*-------------------------------------------------------------
  307.  * public functions
  308.  *
  309.  */
  311. int smsc2_start(Cfg *cfg)
  312. {
  313.     CfgGroup *grp;
  314.     SMSCConn *conn;
  315.     Octstr *os;
  316.     int i;
  318.     if (smsc_running) return -1;
  320.     smsc_list = list_create();
  321.     smsc_groups = list_create();
  323.     grp = cfg_get_single_group(cfg, octstr_imm("core"));
  324.     unified_prefix = cfg_get(grp, octstr_imm("unified-prefix"));
  325.     if (cfg_get_integer(&maximum_queue_length, grp, 
  326.                            octstr_imm("maximum-queue-length")) == -1)
  327.         maximum_queue_length = -1;
  329.     white_list = black_list = NULL;
  330.     os = cfg_get(grp, octstr_imm("white-list"));
  331.     if (os != NULL) {
  332.         white_list = numhash_create(octstr_get_cstr(os));
  333. octstr_destroy(os);
  334.     }
  335.     os = cfg_get(grp, octstr_imm("black-list"));
  336.     if (os != NULL) {
  337.         black_list = numhash_create(octstr_get_cstr(os));
  338. octstr_destroy(os);
  339.     }
  341.     smsc_groups = cfg_get_multi_group(cfg, octstr_imm("smsc"));
  342.     /*
  343.     while(groups && (grp = list_extract_first(groups)) != NULL) {
  344.         conn = smscconn_create(grp, 1); 
  345.         if (conn == NULL)
  346.             panic(0, "Cannot start with SMSC connection failing");
  347.         
  348.         list_append(smsc_list, conn);
  349.     }
  350.     */
  351.     list_add_producer(smsc_list);
  352.     for (i = 0; i < list_len(smsc_groups) && 
  353.         (grp = list_get(smsc_groups, i)) != NULL; i++) {
  354.         conn = smscconn_create(grp, 1); 
  355.         if (conn == NULL)
  356.             panic(0, "Cannot start with SMSC connection failing");
  357.         list_append(smsc_list, conn);
  358.     }
  359.     list_remove_producer(smsc_list);
  360.     
  361.     if ((router_thread = gwthread_create(sms_router, NULL)) == -1)
  362. panic(0, "Failed to start a new thread for SMS routing");
  363.     
  364.     list_add_producer(incoming_sms);
  365.     list_add_producer(incoming_wdp);
  366.     smsc_running = 1;
  367.     return 0;
  368. }
  370. static int smsc2_find(Octstr *id)
  371. {
  372.     SMSCConn *conn = NULL;
  373.     int i;
  375.     list_lock(smsc_list);
  376.     for (i = 0; i < list_len(smsc_list); i++) {
  377.         conn = list_get(smsc_list, i);
  378.         if (conn != NULL && octstr_compare(conn->id, id) == 0) {
  379.             break;
  380.         }
  381.     }
  382.     list_unlock(smsc_list);
  383.     if (i >= list_len(smsc_list))
  384.         i = -1;
  385.     return i;
  386. }
  388. int smsc2_stop_smsc(Octstr *id)
  389. {
  390.     SMSCConn *conn;
  391.     int i;
  393.     /* find the specific smsc via id */
  394.     if ((i = smsc2_find(id)) == -1) {
  395.         error(0, "HTTP: Could not shutdown smsc-id `%s'", octstr_get_cstr(id));
  396.         return -1;
  397.     }
  398.     conn = list_get(smsc_list, i);
  399.     if (conn != NULL && conn->status == SMSCCONN_DEAD) {
  400.         error(0, "HTTP: Could not shutdown already deaed smsc-id `%s'", 
  401.               octstr_get_cstr(id));
  402.         return -1;
  403.     }
  404.     info(0,"HTTP: Shutting down smsc-id `%s'", octstr_get_cstr(id));
  405.     smscconn_shutdown(conn, 1);   /* shutdown the smsc */
  406.     return 0;
  407. }
  409. int smsc2_restart_smsc(Octstr *id)
  410. {
  411.     CfgGroup *grp;
  412.     SMSCConn *conn;
  413.     Octstr *smscid;
  414.     int i;
  416.     /* find the specific smsc via id */
  417.     if ((i = smsc2_find(id)) == -1) {
  418.         error(0, "HTTP: Could not re-start non defined smsc-id `%s'", 
  419.               octstr_get_cstr(id));
  420.         return -1;
  421.     }
  423.     /* check if smsc is online status already */
  424.     conn = list_get(smsc_list, i);
  425.     if (conn != NULL && conn->status != SMSCCONN_DEAD) {
  426.         error(0, "HTTP: Could not re-start already running smsc-id `%s'", 
  427.               octstr_get_cstr(id));
  428.         return -1;
  429.     }
  430.   
  431.     list_delete(smsc_list, i, 1); /* drop it from the active smsc list */
  432. smscconn_destroy(conn);       /* destroy the connection */
  434.     /* find the group with smsc id */
  435.     grp = NULL;
  436.     list_lock(smsc_groups);
  437.     for (i = 0; i < list_len(smsc_groups) && 
  438.         (grp = list_get(smsc_groups, i)) != NULL; i++) {
  439.         smscid = cfg_get(grp, octstr_imm("smsc-id"));
  440.         if (smscid != NULL && octstr_compare(smscid, id) == 0) {
  441.             break;
  442.         }
  443.     }
  444.     list_unlock(smsc_groups);
  445.     if (i > list_len(smsc_groups))
  446.         return -1;
  447.     
  448.     info(0,"HTTP: Re-starting smsc-id `%s'", octstr_get_cstr(id));
  450.     conn = smscconn_create(grp, 1); 
  451.     if (conn == NULL)
  452.         error(0, "Cannot start with SMSC connection failing");
  453.     list_append(smsc_list, conn);
  455.     smscconn_start(conn);
  456.     if (router_thread >= 0)
  457.         gwthread_wakeup(router_thread);
  459.     return 0;
  460. }
  462. void smsc2_resume(void)
  463. {
  464.     SMSCConn *conn;
  465.     int i;
  466.     
  467.     for (i = 0; i < list_len(smsc_list); i++) {
  468.         conn = list_get(smsc_list, i);
  469.         smscconn_start(conn);
  470.     }
  471.     if (router_thread >= 0)
  472. gwthread_wakeup(router_thread);
  473. }
  476. void smsc2_suspend(void)
  477. {
  478.     SMSCConn *conn;
  479.     int i;
  480.     
  481.     list_lock(smsc_list);
  482.     for (i = 0; i < list_len(smsc_list); i++) {
  483.         conn = list_get(smsc_list, i);
  484.         smscconn_stop(conn);
  485.     }
  486.     list_unlock(smsc_list);
  487. }
  490. int smsc2_shutdown(void)
  491. {
  492.     SMSCConn *conn;
  493.     int i;
  495.     if (!smsc_running) return -1;
  497.     /* Call shutdown for all SMSC Connections; they should
  498.      * handle that they quit, by emptying queues and then dying off
  499.      */
  500.     list_lock(smsc_list);
  501.     for(i=0; i < list_len(smsc_list); i++) {
  502.         conn = list_get(smsc_list, i);
  503. smscconn_shutdown(conn, 1);
  504.     }
  505.     list_unlock(smsc_list);
  506.     if (router_thread >= 0)
  507. gwthread_wakeup(router_thread);
  509.     /* start avalanche by calling shutdown */
  511.     /* XXX shouldn'w we be sure that all smsces have closed their
  512.      * receive thingies? Is this guaranteed by setting bb_status
  513.      * to shutdown before calling these?
  514.      */
  515.     list_remove_producer(incoming_sms);
  516.     list_remove_producer(incoming_wdp);
  517.     return 0;
  518. }
  521. void smsc2_cleanup(void)
  522. {
  523.     SMSCConn *conn;
  524.     int i;
  526.     debug("smscconn", 0, "final clean-up for SMSCConn");
  527.     
  528.     list_lock(smsc_list);
  529.     for (i = 0; i < list_len(smsc_list); i++) {
  530.         conn = list_get(smsc_list, i);
  531.         smscconn_destroy(conn);
  532.     }
  533.     list_unlock(smsc_list);
  534.     list_destroy(smsc_list, NULL);
  535.     list_destroy(smsc_groups, NULL);
  536.     octstr_destroy(unified_prefix);    
  537.     numhash_destroy(white_list);
  538.     numhash_destroy(black_list);
  539. }
  542. Octstr *smsc2_status(int status_type)
  543. {
  544.     Octstr *tmp;
  545.     char tmp3[64];
  546.     char *lb;
  547.     int i, para = 0;
  548.     SMSCConn *conn;
  549.     StatusInfo info;
  550.     Octstr *conn_id = NULL;
  551.     Octstr *conn_name = NULL;
  553.     if ((lb = bb_status_linebreak(status_type)) == NULL)
  554.         return octstr_create("Un-supported format");
  556.     if (status_type == BBSTATUS_HTML || status_type == BBSTATUS_WML)
  557.         para = 1;
  559.     if (!smsc_running) {
  560.         if (status_type == BBSTATUS_XML)
  561.             return octstr_create ("<smscs>nt<count>0</count>n</smscs>");
  562.         else
  563.             return octstr_format("%sNo SMSC connections%snn", para ? "<p>" : "",
  564.                                  para ? "</p>" : "");
  565.     }
  567.     if (status_type != BBSTATUS_XML)
  568.         tmp = octstr_format("%sSMSC connections:%s", para ? "<p>" : "", lb);
  569.     else
  570.         tmp = octstr_format("<smscs><count>%d</count>nt", list_len(smsc_list));
  571.     
  572.     list_lock(smsc_list);
  573.     for (i = 0; i < list_len(smsc_list); i++) {
  574.         conn = list_get(smsc_list, i);
  576.         if ((smscconn_info(conn, &info) == -1)) {
  577.             /* 
  578.              * we do not delete SMSCs from the list 
  579.              * this way we can show in the status which links are dead
  580.              */
  581.             continue;
  582.         }
  584.         conn_id = conn ? smscconn_id(conn) : octstr_imm("unknown");
  585.         conn_id = conn_id ? conn_id : octstr_imm("unknown");
  586.         conn_name = conn ? smscconn_name(conn) : octstr_imm("unknown");
  588.         if (status_type == BBSTATUS_HTML) {
  589.             octstr_append_cstr(tmp, "&nbsp;&nbsp;&nbsp;&nbsp;<b>");
  590.             octstr_append(tmp, conn_id);
  591.             octstr_append_cstr(tmp, "</b>&nbsp;&nbsp;&nbsp;&nbsp;");
  592.         } else if (status_type == BBSTATUS_TEXT) {
  593.             octstr_append_cstr(tmp, "    ");
  594.             octstr_append(tmp, conn_id);
  595.             octstr_append_cstr(tmp, "    ");
  596.         } 
  597.         if (status_type == BBSTATUS_XML) {
  598.             octstr_append_cstr(tmp, "<smsc>ntt<name>");
  599.             octstr_append(tmp, conn_name);
  600.             octstr_append_cstr(tmp, "</name>ntt");
  601.             octstr_append_cstr(tmp, "<id>");
  602.             octstr_append(tmp, conn_id);
  603.             octstr_append_cstr(tmp, "</id>ntt");
  604.         } else
  605.             octstr_append(tmp, conn_name);
  607.         switch (info.status) {
  608.             case SMSCCONN_ACTIVE:
  609.             case SMSCCONN_ACTIVE_RECV:
  610.                 sprintf(tmp3, "online %lds", info.online);
  611.                 break;
  612.             case SMSCCONN_DISCONNECTED:
  613.                 sprintf(tmp3, "disconnected");
  614.                 break;
  615.             case SMSCCONN_CONNECTING:
  616.                 sprintf(tmp3, "connecting");
  617.                 break;
  618.             case SMSCCONN_RECONNECTING:
  619.                 sprintf(tmp3, "re-connecting");
  620.                 break;
  621.             case SMSCCONN_DEAD:
  622.                 sprintf(tmp3, "dead");
  623.                 break;
  624.             default:
  625.                 sprintf(tmp3, "unknown");
  626.         }
  628.         if (status_type == BBSTATUS_XML)
  629.             octstr_format_append(tmp, "<status>%s</status>ntt<received>%ld</received>"
  630.                 "ntt<sent>%ld</sent>ntt<failed>%ld</failed>ntt"
  631.                 "<queued>%ld</queued>nt</smsc>n", tmp3,
  632.                 info.received, info.sent, info.failed,
  633.                 info.queued);
  634.         else
  635.             octstr_format_append(tmp, " (%s, rcvd %ld, sent %ld, failed %ld, "
  636.                 "queued %ld msgs)%s", tmp3,
  637.             info.received, info.sent, info.failed,
  638.             info.queued, lb);
  639.     }
  640.     list_unlock(smsc_list);
  642.     if (para)
  643.         octstr_append_cstr(tmp, "</p>");
  644.     if (status_type == BBSTATUS_XML)
  645.         octstr_append_cstr(tmp, "</smscs>n");
  646.     else
  647.         octstr_append_cstr(tmp, "nn");
  648.     return tmp;
  649. }
  652. /* function to route outgoing SMS'es
  653.  *
  654.  * If finds a good one, puts into it and returns 1
  655.  * If finds only bad ones, but acceptable, queues and
  656.  *  returns 0  (like all acceptable currently disconnected)
  657.  * If cannot find nothing at all, returns -1 and
  658.  * message is NOT destroyed (otherwise it is)
  659.  */
  660. int smsc2_rout(Msg *msg)
  661. {
  662.     StatusInfo info;
  663.     SMSCConn *conn, *best_preferred, *best_ok;
  664.     long bp_load, bo_load;
  665.     int i, s, ret, bad_found;
  666.     char *uf;
  668.     bp_load = bo_load = 0;
  670.     /* XXX handle ack here? */
  671.     if (msg_type(msg) != sms)
  672. return -1;
  673.     
  674.     if (list_len(smsc_list) == 0) {
  675. warning(0, "No SMSCes to receive message");
  676. return -1;
  677.     }
  679.     /* unify prefix of receiver, in case of it has not been
  680.      * already done */
  682.     uf = unified_prefix ? octstr_get_cstr(unified_prefix) : NULL;
  683.     normalize_number(uf, &(msg->sms.receiver));
  684.             
  685.     /* select in which list to add this
  686.      * start - from random SMSCConn, as they are all 'equal'
  687.      */
  689.     list_lock(smsc_list);
  691.     s = gw_rand() % list_len(smsc_list);
  692.     best_preferred = best_ok = NULL;
  693.     bad_found = 0;
  694.     
  695.     conn = NULL;
  696.     for (i=0; i < list_len(smsc_list); i++) {
  697. conn = list_get(smsc_list,  (i+s) % list_len(smsc_list));
  699. ret = smscconn_usable(conn,msg);
  700. if (ret == -1)
  701.     continue;
  703. /* if we already have a preferred one, skip non-preferred */
  704. if (ret != 1 && best_preferred)
  705.     continue;
  707. smscconn_info(conn, &info);
  708. /* If connection is not currently answering... */
  709. if (info.status != SMSCCONN_ACTIVE) {
  710.     bad_found = 1;
  711.     continue;
  712. }
  713. if (ret == 1) {          /* preferred */
  714.     if (best_preferred == NULL || info.load < bp_load) {
  715. best_preferred = conn;
  716. bp_load = info.load;
  717. continue;
  718.     }
  719. }
  720. if (best_ok == NULL || info.load < bo_load) {
  721.     best_ok = conn;
  722.     bo_load = info.load;
  723. }
  724.     }
  725.     list_unlock(smsc_list);
  727.     if (best_preferred)
  728. ret = smscconn_send(best_preferred, msg);
  729.     else if (best_ok)
  730. ret = smscconn_send(best_ok, msg);
  731.     else if (bad_found) {
  732. if (bb_status != BB_SHUTDOWN)
  733.     list_produce(outgoing_sms, msg);
  734. return 0;
  735.     }
  736.     else {
  737. if (bb_status == BB_SHUTDOWN)
  738.     return 0;
  739. warning(0, "Cannot find SMSCConn for message to <%s>, rejected.",
  740. octstr_get_cstr(msg->sms.receiver));
  741. return -1;
  742.     }
  743.     /* check the status of sending operation */
  744.     if (ret == -1)
  745. return (smsc2_rout(msg)); /* re-try */
  747.     msg_destroy(msg);
  748.     return 1;
  749. }