connectionMgr/src/connectScan.c Source File

00001 /*
00002  * This file is part of connectionMgr.
00003  *
00004  * connectionMgr is free software: you can redistribute it and/or modify
00005  * it under the terms of the GNU General Public License as published by
00006  * the Free Software Foundation, either version 2 of the License, or
00007  * (at your option) any later version.
00008  *
00009  * connectionMgr is distributed in the hope that it will be useful,
00010  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
00012  * GNU General Public License for more details.
00013  *
00014  * You should have received a copy of the GNU General Public License
00015  * along with this program. If not, see <http://www.gnu.org/licenses/>.
00016  */
00017 
00026 #include <gtk/gtk.h>
00027 #include <glib.h>
00028 #include <string.h>
00029 
00030 #include "connectionMgrLog.h"
00031 #include "scanThread.h"
00032 #include "connectScan.h"
00033 #include "background.h"
00034 #include "erbusy.h"
00035     
00036 static void connect_scan_ctxt_destory_results(scanContext_t* ctxt);
00037 static void connect_scan_ctxt_empty_results(scanContext_t* ctxt);
00038 
00039 static gboolean connect_scan_start(gpointer data);
00040 static void     connect_scan_done (scanContext_t* ctxt);
00041 
00042 static void wireless_scan_start(scanContext_t* ctxt);
00043 
00044 
00045 static void     on_scan_status_changed (GObject *object, 
00046                                         GParamSpec *arg, 
00047                                         gpointer data);
00048 
00049 scanContext_t* connect_scan_ctxt_new(void)
00050 {
00051     scanContext_t* ctxt;
00052     GtkWidget* scanStatus;
00053 
00054     ctxt = g_new0(scanContext_t, 1);
00055     g_assert(ctxt != NULL);
00056 
00057     // initilize the scanParams
00058     ctxt->scanParms = g_new0(scan_thread_parms, 1);
00059     g_assert(ctxt->scanParms != NULL);
00060 
00061     scanStatus = gtk_label_new("scan-idle");
00062     g_signal_connect(scanStatus, "notify", 
00063             G_CALLBACK(on_scan_status_changed), ctxt);
00064     ctxt->scanParms->scanStatus = scanStatus;
00065 
00066     // set the default values
00067     connect_scan_ctxt_set_mode(ctxt, undefScanMode_e);
00068     connect_scan_ctxt_set_network_type(ctxt, connection_undefined_t);
00069     connect_scan_ctxt_set_done_callbacks(ctxt, NULL, NULL);
00070 
00071     connect_scan_ctxt_set_ssidlist(ctxt, "");
00072     connect_scan_ctxt_set_max_networks(ctxt, MAX_PROFILES_PER_PAGE);
00073 
00074     // the other values are set to be NULL or zero implicitly by g_new0
00075 
00076     return ctxt;
00077 }
00078 
00079 void connect_scan_ctxt_set_mode(scanContext_t* ctxt, scanMode_t mode)
00080 {
00081     if (ctxt && (mode >= 0) && (mode < undefScanMode_e))
00082     {
00083         ctxt->mode = mode;
00084     }
00085 }
00086 
00087 void connect_scan_ctxt_set_network_type(scanContext_t* ctxt, 
00088                                     connection_t networkType)
00089 {
00090     if (ctxt && (networkType >= 0) && (networkType < connection_undefined_t))
00091     {
00092         ctxt->networkType = networkType;
00093     }
00094 }
00095 
00096 void connect_scan_ctxt_set_done_callbacks(scanContext_t* ctxt, 
00097                                       scan_done_t* scan_done, 
00098                                       scan_done_after_t* scan_done_after)
00099 {
00100     if (ctxt)
00101     {
00102         ctxt->scan_done = scan_done;
00103         ctxt->scan_done_after = scan_done_after;
00104     }
00105 }
00106 
00107 void connect_scan_ctxt_set_ssidlist(scanContext_t* ctxt, gchar* ssidList)
00108 {
00109     if (ctxt && ctxt->scanParms && ssidList)
00110     {
00111         if (ctxt->scanParms->ssid)
00112         {
00113             g_free(ctxt->scanParms->ssid);
00114         }
00115         ctxt->scanParms->ssid = g_strdup(ssidList);
00116     }
00117 }
00118 
00119 void connect_scan_ctxt_set_max_networks(scanContext_t* ctxt, 
00120                                         int maxNetworks)
00121 {
00122     network_spec_t *networks, *pNetwork;
00123     int             i;
00124 
00125     if (ctxt && ctxt->scanParms && (maxNetworks > 0))
00126     {
00127         // destory the old memory for networks
00128         connect_scan_ctxt_destory_results(ctxt);
00129 
00130         // malloc the new memory for networks
00131         networks = g_new0(network_spec_t, maxNetworks);
00132         g_assert(networks != NULL);
00133         for (i = 0; i < maxNetworks; i++)
00134         {
00135             pNetwork = &networks[i];
00136             pNetwork->encryption = encr_none_t;
00137         }
00138         ctxt->scanParms->networks = networks;
00139         ctxt->scanParms->networks_num = maxNetworks;
00140     }
00141 }
00142 
00143 void connect_scan_ctxt_destory(scanContext_t* ctxt)
00144 {
00145     if (ctxt)
00146     {
00147         if (ctxt->scanParms)
00148         {
00149             /*
00150             if (ctxt->scanParms->scanStatus)
00151             {
00152                 gtk_widget_destroy(ctxt->scanParms->scanStatus);
00153             }
00154             */
00155            
00156             if (ctxt->scanParms->ssid)
00157             {
00158                 g_free(ctxt->scanParms->ssid);
00159             }
00160         }
00161 
00162         connect_scan_ctxt_destory_results(ctxt);
00163 
00164         g_free(ctxt->scanParms);
00165         g_free(ctxt);
00166     }
00167 }
00168 
00169 static void connect_scan_ctxt_destory_results(scanContext_t* ctxt)
00170 {
00171     network_spec_t* networks, *pNetwork;
00172     int i, n;
00173 
00174     if (ctxt && ctxt->scanParms)
00175     {
00176         if (ctxt->scanParms->networks)
00177         {
00178             networks = ctxt->scanParms->networks;
00179             n = ctxt->scanParms->networks_num;
00180 
00181             for (i = 0; i < n; i++)
00182             {
00183                 pNetwork = &networks[i];
00184                 if (pNetwork->ssid)
00185                 {
00186                     g_free(pNetwork->ssid);
00187                 }
00188             }
00189             g_free(ctxt->scanParms->networks);
00190             ctxt->scanParms->networks = NULL;
00191             ctxt->scanParms->networks_num = 0;
00192             ctxt->scanParms->networks_found = 0;
00193         }
00194     }
00195 }
00196 
00197 static void connect_scan_ctxt_empty_results(scanContext_t* ctxt)
00198 {
00199     network_spec_t* networks, *pNetwork;
00200     int i, n;
00201 
00202     if (ctxt && ctxt->scanParms)
00203     {
00204         if (ctxt->scanParms->networks)
00205         {
00206             networks = ctxt->scanParms->networks;
00207             n = ctxt->scanParms->networks_num;
00208 
00209             for (i = 0; i < n; i++)
00210             {
00211                 pNetwork = &networks[i];
00212                 if (pNetwork->ssid)
00213                 {
00214                     g_free(pNetwork->ssid);
00215                     pNetwork->ssid = NULL;
00216                 }
00217                 pNetwork->encryption = encr_none_t;
00218                 pNetwork->quality = 0;
00219             }
00220 
00221             ctxt->scanParms->networks_found = 0;
00222         }
00223     }
00224 }
00225 
00226 void connect_scan(scanContext_t* ctxt, gboolean delay)
00227 {
00228     scanMode_t   mode;
00229     connection_t type;
00230 
00231     CN_LOGPRINTF("entry");
00232 
00233     g_return_if_fail(ctxt != NULL);
00234     
00235     mode = ctxt->mode;
00236     type = ctxt->networkType;
00237     if ((mode < 0) || (mode >= undefScanMode_e) 
00238         || (type < 0) || (type >= connection_undefined_t))
00239     {
00240         CN_ERRORPRINTF("Invalid arguments: mode[%d] type[%d]", mode, type);
00241         return;
00242     }
00243 
00244     if (ctxt->scanNetworks)
00245     {
00246         CN_WARNPRINTF("Please wait while scanning");
00247         return;
00248     }
00249 
00250     if (delay)
00251     {
00252         if (ctxt->scanTimeoutId > 0)
00253         {
00254             CN_LOGPRINTF("remove the old timeout function for scaning");
00255             g_source_remove(ctxt->scanTimeoutId);
00256             ctxt->scanTimeoutId = 0;
00257         }
00258 
00259         // begin to scan after 5s timeout
00260         if (ctxt->networkType == wireless_t)
00261         {
00262             ctxt->scanTimeoutId = g_timeout_add(200, 
00263                                                 connect_scan_start, 
00264                                                 (gpointer)ctxt);
00265         }
00266         else
00267         {
00268             ctxt->scanTimeoutId = g_timeout_add(5000, 
00269                                                 connect_scan_start, 
00270                                                 (gpointer)ctxt);
00271         }
00272     }
00273     else
00274     {
00275         connect_scan_start((gpointer)ctxt);
00276     }
00277 }
00278 
00279 static gboolean connect_scan_start(gpointer data)
00280 {
00281     CN_LOGPRINTF("entry");
00282 
00283     scanContext_t* ctxt;
00284 
00285     ctxt = (scanContext_t*)data;
00286     g_return_val_if_fail(ctxt != NULL, FALSE);
00287 
00288     if (ctxt->mode != backgroundScan_e)
00289     {
00290         // busybar begins to blink
00291         erbusy_blink();
00292     }
00293 
00294     // set the flag to be TRUE
00295     ctxt->scanNetworks = TRUE;
00296 
00297     if (ctxt->networkType == wireless_t)
00298     {
00299         // start scanning wireless
00300         wireless_scan_start(ctxt);
00301     }
00302     else
00303     {   
00304         // get the network profiles according to the 'networkType'
00305         if (ctxt->scan_done)
00306         {
00307             ctxt->scan_done(ctxt->networkType, NULL, 0);
00308         }
00309 
00310         // finished scan networks
00311         connect_scan_done(ctxt);
00312     }
00313 
00314     ctxt->scanTimeoutId = 0;
00315     
00316     // don't call me again
00317     return FALSE; 
00318 }
00319 
00320 static void connect_scan_done (scanContext_t* ctxt)
00321 {
00322     CN_LOGPRINTF("entry");
00323    
00324     g_return_if_fail(ctxt != NULL);
00325 
00326     if (ctxt->scanNetworks)
00327     {
00328         // set the flag back to FALSE
00329         ctxt->scanNetworks = FALSE;
00330 
00331         if (ctxt->scan_done_after)
00332         {
00333             ctxt->scan_done_after();
00334         }
00335 
00336         if (ctxt->mode != backgroundScan_e)
00337         {
00338             erbusy_off();
00339         }
00340     }
00341 }
00342 
00343 gboolean connect_scan_freeze_ui(scanContext_t* ctxt)
00344 {
00345     g_return_val_if_fail(ctxt != NULL, FALSE);
00346 
00347     CN_LOGPRINTF("return freeze = %d", ctxt->scanAborting);
00348     return ctxt->scanAborting;
00349 }
00350 
00351 static gboolean delay_connect_scan_abort(gpointer data)
00352 {
00353     scanContext_t* ctxt;
00354     gboolean       ret = TRUE;  // TRUE = please call again
00355 
00356     ctxt = (scanContext_t*)data;
00357     g_return_val_if_fail(ctxt != NULL, FALSE);
00358 
00359     // wait the scanThread aborting
00360     if (!scanThread_stopped())
00361     {
00362         CN_LOGPRINTF("call me later...");
00363     }
00364     else
00365     {
00366         ctxt->scanAborting = FALSE;
00367         
00368         // no more scan ongoing
00369         ctxt->scanNetworks = FALSE;
00370 
00371         ret = FALSE;  // FALSE = don't call me again
00372     }
00373 
00374     return ret;
00375 }
00376 
00377 void connect_scan_abort(scanContext_t* ctxt)
00378 {
00379     CN_LOGPRINTF("entry");
00380 
00381     g_return_if_fail(ctxt != NULL);
00382 
00383     if (ctxt->scanNetworks)
00384     {
00385         CN_WARNPRINTF("Abort scanning...");
00386 
00387         if (ctxt->mode != backgroundScan_e)
00388         {
00389             erbusy_blink();
00390         }
00391 
00392         if (ctxt->networkType == wireless_t)
00393         {
00394             // stop the scan thread
00395             scanThread_stop();
00396 
00397             // wait for scanThread done
00398             ctxt->scanAborting = TRUE;
00399             g_timeout_add(200, delay_connect_scan_abort, (gpointer)ctxt);
00400         }
00401         else
00402         {
00403             // set the flag back to FALSE
00404             ctxt->scanNetworks = FALSE;
00405         }
00406 
00407         if (ctxt->mode != backgroundScan_e)
00408         {
00409             erbusy_off();
00410         }
00411     }
00412 }
00413 
00414 static void wireless_scan_start(scanContext_t* ctxt)
00415 {
00416     gboolean ok;
00417 
00418     CN_LOGPRINTF("entry");
00419 
00420     g_return_if_fail(ctxt != NULL);
00421 
00422     // clear old network info
00423     connect_scan_ctxt_empty_results(ctxt);
00424 
00425     CN_LOGPRINTF("Scanning for ssid[%s]", 
00426             ctxt->scanParms ? ctxt->scanParms->ssid : ""); 
00427 
00428     // start scan thread
00429     ok = scanThread_start(ctxt->scanParms);
00430     if (ok && (ctxt->mode != backgroundScan_e))
00431     {
00432         erbusy_blink();
00433     }
00434 }
00435 
00436 // signal handler for scan status change
00437 static void on_scan_status_changed(GObject *object, 
00438                                    GParamSpec *arg, 
00439                                    gpointer data)
00440 {
00441     CN_LOGPRINTF("entry");
00442 
00443     scanContext_t* ctxt = (scanContext_t*)data;
00444     g_return_if_fail(ctxt != NULL);
00445     
00446     const char *name = arg->name;
00447     g_return_if_fail(strcmp(name,"label") == 0);
00448 
00449     const gchar* scanStatus = gtk_label_get_text(GTK_LABEL(object));
00450     CN_LOGPRINTF("scanStatus [%s]", scanStatus);
00451 
00452     if (strcmp(scanStatus, "scan-done-ok") == 0)
00453     {
00454         if (ctxt->mode != backgroundScan_e)
00455         {
00456             erbusy_off();
00457         }
00458        
00459         gtk_label_set_text(GTK_LABEL(ctxt->scanParms->scanStatus)
00460                 /*GTK_LABEL(object)*/,"scan-idle");
00461         
00462         if (ctxt->scan_done)
00463         {
00464             ctxt->scan_done(wireless_t,
00465                             ctxt->scanParms->networks, 
00466                             ctxt->scanParms->networks_found);
00467         }
00468 
00469         connect_scan_done(ctxt);
00470     }
00471 }
00472