>> reference.c:3:16: error: expected ‘;’, ‘,’ or ‘)’ before ‘&’ token
>>  void myfun(int &a){
>>                 ^
>> reference.c: In function ‘main’:
>> reference.c:13:4: warning: implicit declaration of function ‘myfun’
>> [-Wimplicit-function-declaration]
>>     myfun(a);
>>     ^

> katolaz@%%%%%%:~/test$ gcc -std=c11 reference.c
> reference.c:3:16: error: expected ‘;’, ‘,’ or ‘)’ before ‘&’ token
>  void myfun(int &a){
>                 ^
> reference.c: In function ‘main’:
> reference.c:13:4: warning: implicit declaration of function ‘myfun’
> [-Wimplicit-function-declaration]
>     myfun(a);
>     ^

    netman - A Network Connection Manager
    Copyright (C) 2015  Edward Bartolo

    "netman" is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    "netman" is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with "netman".  If not, see <http://www.gnu.org/licenses/>.
*/

The return value is a list of strings containing the encoded essid file names.
count returns the number of strings in the list and error returns a non-zero error code
in the event of an error with a value of zero when no error is generated.
*/
char** getInstalledEssidList(int etc_network_path, int* count, int* error)
{
    char** essid_list;

    DIR * dir;
    struct dirent * ent;
    int el_size = 0; // stands for essid_list size

    essid_list = NULL;

    // At first set *error to 0
    *error = 0;

    // First get a list of installed wireless "interfaces" files
    if (etc_network_path )
      dir = opendir(IFACES_PATH);
      else dir = opendir(RUN_IFACES_PATH);

    if (dir != NULL) {
        while ((ent = readdir (dir)) != 0)
            if(
                strcmp(".", ent->d_name) != 0 && 
                strcmp("..", ent->d_name) != 0
            ) {
                (*count)++;

                char* encoded_essid;
                int err;

                encoded_essid = ent->d_name;    
                if (el_size < *count) {
                    el_size =+ 10;
                    if (el_size == 10)
                        essid_list = calloc(*count + 9, sizeof(char*));
                        else essid_list = realloc(essid_list, (*count + 9)*sizeof(char*));

                    if (essid_list == NULL || errno == ENOMEM) {    
                        fprintf(
                            stderr, 
                            "ERROR: getInstalledEssidList(): "
                            "could not expand essid_list list. (Error: %s)\n", 
                            strerror(errno)
                        );

                        el_size =- 10;
                        (*count)--;

                        *error = 1;
                        return essid_list;
                    }    
                }    

                char* essid;    
                err = decode_essid_alloc(encoded_essid, &essid);

                if(err) {
                    fprintf(
                        stderr, "ERROR: "
                        "getInstalledEssidList(): decode_essid_alloc(encoded_essid=%s) failed; err=%d\n",
                        encoded_essid, err
                    );

                    (*count)--;

                    *error = 1;
                    return essid_list;
                    //continue;
                }

                err = decode_encoded_essid(encoded_essid, &essid);

                if(err) {
                    fprintf(
                        stderr, "ERROR: "
                        "getInstalledEssidList(): decode_encoded_essid(encoded_essid=%s) failed; err=%d\n",
                        encoded_essid, err
                    );

                    *error = -1;
                    return essid_list;
                }

                essid_list[*count - 1] = essid;

                //essid_list[*count - 1] = calloc(strlen(encoded_essid) + 1, sizeof(char));
                //strcpy(essid_list[*count - 1], encoded_essid);
            } 
        closedir(dir);
    } 
    else {
        if (etc_network_path) {
            fprintf(
                stderr, "Error: "
                "getInstalledEssidList(): opendir(%s) failed (Error: %s)\n",
                IFACES_PATH, strerror(errno)
            );
        } else {
            fprintf(
                stderr, "Error: "
                "getInstalledEssidList(): opendir(%s) failed (Error: %s)\n",
                RUN_IFACES_PATH, strerror(errno)
            );
        };        

        //return old_errno;
        *error = 1;
        return essid_list;
    }

    //return 0;
    return essid_list;
}

/*
Runs "iwlist wlanx or equivalent scan" to get a list of active wifi transceivers in 
the vicinity. The return value is a list of strings of type void** implying type casting
must be used to access the strings. 
active_wifis returns the number of active wifi transceivers found and error contains a non zero
error code in the event of an error, otherwise zero is returned.
*/
void** getRadiatingWifiList(int* active_wifis, int* error)
{
    // Hopefully, here we have a list of installed essid interfaces files
    void** active_wifi_list = NULL;

    char command[1024];
    FILE * shell_reader;
    char * scan_buffer;
    int err;

    *error = 0;    
    scan_buffer = calloc(1024, 1);

    if (scan_buffer == NULL) {
        fprintf(
            stderr, 
            "ERROR: getRadiatingWifiList(): "
            "calloc() failed to allocate memory for scan_buffer. (Error: %s)\n", 
            strerror(errno)
        );

        *error = 2;

        return NULL;
    }

    err = snprintf(
        command, 
        1024,
        "/sbin/iwlist %s scan | grep \"Quality=\\|ESSID:\"",
        wlanx
    );

    if(err<0) {
        fprintf(stderr, "ERROR: snprintf(filename) failed; err=%d\n", err);
        free(scan_buffer);
    }

    // read output lines containing 'Quality=' and 'ESSID:'
    shell_reader = popen(command, "r");

    if(!shell_reader) {
        fprintf(
            stderr, 
            "ERROR: getRadiatingWifiList(): "
            "popen() failed (Error: %s)\n", 
            strerror(errno)
        );

        free(scan_buffer);
        *error = 2;

        return NULL;
    }

    wifi_quality* tmp_wifi_quality;
    int z = 0;

    *active_wifis = -1;
    char* tmp_buffer = scan_buffer;

    const int list_delta = 10;
    while((scan_buffer = fgets(scan_buffer, 1024, shell_reader)))
    {
        z++;
        if (z == 1) 
            active_wifi_list = calloc(list_delta, sizeof(void*));
        else if ((z - 1) % (list_delta * 2) == 0)
            active_wifi_list = realloc(active_wifi_list, (((z - 1)/2) + list_delta)*sizeof(void*));

        if (active_wifi_list == NULL || errno == ENOMEM) {
            fprintf(
                stderr, 
                "ERROR: getRadiatingWifiList(): "
                "could not expand active_wifi_list. (Error: %s)\n", 
                strerror(errno)
            );

            free(tmp_buffer);
            *error = 2;

            return active_wifi_list;
        }

        if (z % 2 == 1) {
                (*active_wifis)++;
                tmp_wifi_quality = calloc(1, sizeof(wifi_quality));

                if (tmp_wifi_quality == NULL) {
                    fprintf(
                        stderr, 
                        "ERROR: getRadiatingWifiList(): "
                        "could not allocate tmp_wifi_quality. (Error: %s)\n", 
                        strerror(errno)
                    );

                    (*active_wifis)++;
                    free(tmp_buffer);
                    *error = 2;

                    return active_wifi_list;
                }

                active_wifi_list[*active_wifis] = tmp_wifi_quality;

                char* substr = strstr((char *) scan_buffer, "Signal level=");
                substr = strstr(substr, "=");
                char* endstr = strstr(substr + 1, " ");
                char tmpstr[MAX_ESSID_LENGTH];
                strncpy(tmpstr, substr + 1, endstr - substr - 1);
                tmpstr[endstr - substr - 1] = '\0';

                tmp_wifi_quality->quality = strtod(tmpstr, NULL);

                // P(dBm) = 10 · log10( P(mW) / 1mW)
                // we want the absolute power

                // P(mW) / 1mW = P*
                // P* = antilog(P/10)

                double log_quality = (tmp_wifi_quality->quality)/10;
                tmp_wifi_quality->quality = pow(10, log_quality);
          }
        else {
                char* tmpstr = strtok((char*) scan_buffer, "\"");
                tmpstr = strtok(NULL, "\"");    

                strncpy(tmp_wifi_quality->name,  tmpstr, strlen(tmpstr)); 
            }
        //printf("%s", scan_buffer);
    }

    free(tmp_buffer);
    pclose(shell_reader);

    return active_wifi_list;    
}

// sort radiating wifis according to signal strength
int sortRadiatingWifisList(const int active_wifis, void** active_wifi_list)
{
    int i, j = 0;
    while (j < active_wifis) {
        for (i = active_wifis - j - 1; i > -1; i--) {
            if (
                ((wifi_quality*) active_wifi_list[i])->quality <
                ((wifi_quality*) active_wifi_list[i + 1])->quality
            ) {
                wifi_quality* awifi_quality = (wifi_quality*) active_wifi_list[i];
              active_wifi_list[i] = active_wifi_list[i + 1];
                active_wifi_list[i + 1] = awifi_quality;
            }
        }

        j++;
    }

    return 0;
}

/*
Checks whether essid is listed in installed_wifi_list. Return index of essid in list or -1
if essid is not found.
*/
int wifiEssidInstalled(const int installed_count, char** installed_wifi_list, char* essid)
{
    int i;
    for (i = 0; i < installed_count; i++) {
        if (strcmp(installed_wifi_list[i], essid) == 0) {
            return i;
        }
    }

    return -1;    // ie not found
}

int autoWirelessScanPlus()
{
    char** essid_list;
    int count = 0;
    int error = 0;

    int active_wifis;
    void** active_wifi_list;

    char scan_buffer[1025];

    // pull up the network to enable scanning
    char command_up[1024];

    int err = snprintf(
        command_up, 
        1024, 
        "/sbin/ifconfig %s up",
        wlanx
    );    

    if(err < 0) {
        fprintf(stderr, "ERROR: snprintf(command_up) failed; err=%d\n", err);

        return err;
    }

    int ret = system(command_up);
    if (ret != 0) {
        fprintf(
            stderr, 
            "ERROR: autoWirelessScanPlus(): "
            "/sbin/ifconfig() failed (Error: %s)\n", 
            strerror(errno)
        );

        return ret;
    }

    // get a list of currently installed wifi essids
    essid_list = getInstalledEssidList(0, &count, &error);
    if (error) {
        int w;
        if (essid_list != NULL) {
            for (w = 0; w < count; w++)
                free(essid_list[w]);

            free(essid_list);
        }

        return 1;
    }    

    // get a list of irradiating wifis
    active_wifi_list = getRadiatingWifiList(&active_wifis, &error);
    if (error) {
        int w;
        for (w = 0; w < count; w++)
            free(essid_list[w]);

        free(essid_list);

        if (active_wifi_list != NULL) {
          for (w = 0; w < active_wifis; w++)
                free(active_wifi_list[w]);

            free(active_wifi_list);    
        }

        return 2;
    }

    // sort the radiating wifis in descending order according to strength
    sortRadiatingWifisList(active_wifis, active_wifi_list);
/*    
    int ww;
    for (ww = 0; ww <= active_wifis; ww++)
      fprintf(stdout, "quality for %s is %g\n", 
            ((wifi_quality*) active_wifi_list[ww])->name,
          ((wifi_quality*) active_wifi_list[ww])->quality);
*/    
    int wireless = 0;
    int counter;

    for (counter = 0; counter < active_wifis; counter++) {
        char* tmp_essid_list_item = ((wifi_quality*) active_wifi_list[counter])->name;

        if (wifiEssidInstalled(count, essid_list, tmp_essid_list_item) > -1) {
            FILE * shell_reader;

            // required command for popen: /sbin/ifup wlanx -i RUN_IFACES_PATH"/"essid_list[counter]
            ;
            char ifup_cmd[40 + MAX_ESSID_LENGTH];

            char** tmp_enc_essid;
            tmp_enc_essid = malloc(sizeof(void*));
            encodeString(tmp_essid_list_item, tmp_enc_essid);
            //printf(encoded_essid);

            err = snprintf(
                ifup_cmd,
                1024,
                "/sbin/ifup %s -i \""RUN_IFACES_PATH"/%s\"",
                wlanx,
                *tmp_enc_essid
                //tmp_essid_list_item
            );

            free(tmp_enc_essid[0]);
            free(tmp_enc_essid);    

            if(err<0) {
                fprintf(stderr, "ERROR: snprintf(filename) failed; err=%d\n", err);

                error = 5;
                break;
            }

            shell_reader = popen(ifup_cmd, "r");

            if(!shell_reader) {
                fprintf(
                    stderr, 
                    "ERROR: autoWirelessScanPlus(): "
                    "popen() failed (Error: %s)\n", 
                    strerror(errno)
                );

                error = 3;
                break;
            }

            pclose(shell_reader);

            shell_reader = popen(
                "/bin/ip a | grep \"state UP\"", "r"
            );

            if(!shell_reader) {
                fprintf(
                    stderr, 
                    "ERROR: autoWirelessScanPlus(): "
                    "popen() failed (Error: %s)\n", 
                    strerror(errno)
                );

                error = 4;
                break;
            }

            while((fgets(scan_buffer, 1024, shell_reader))) {
                if (strstr((char *) scan_buffer, wlanx) != NULL)
                    wireless++;
                //else if (strstr((char *) scan_buffer, "eth0") != NULL)
                //    wired++;
            }

            pclose(shell_reader);
            if (wireless) break; // if connected to wireless stop iterating
        }
    }

    // free the essid string list
    int u;
    for (u = 0; u < count; u++)
      free(essid_list[u]);

    free(essid_list);

    // free the radiating wifis list
    for (u = 0; u <= active_wifis; u++)
        free((wifi_quality*) active_wifi_list[u]);

    free((void*) active_wifi_list);

    return error;    
}

int autoWirelessScanPlus_RN()
{
    DIR * dir;
    struct dirent * ent;
    char* encoded_essid;
    int error;

    if ( (dir = opendir(IFACES_PATH)) != NULL ) {
        while ( (ent = readdir (dir)) != 0)
            if(
                strcmp(".", ent->d_name) != 0 && 
                strcmp("..", ent->d_name) != 0
            ) {
                encoded_essid = ent->d_name;

                error = moveEditEssidFile(wlanx, encoded_essid);
                if (error) break;    
            }

        closedir(dir);        
    }

    if(!dir) {
        fprintf(
            stderr, 
            "ERROR: autoWirelessScanPlus_RN(): "
            "opendir() failed (Error: %s)\n", 
            strerror(errno)
        );

        return errno;    
    }

    if (!error)
        error = autoWirelessScanPlus();

    return error;    
}