change wifi Logging header

    Allocate the memory at JNI layer. Thus, instead pass
    down ** , pass * down

Bug:20853404
Change-Id: I0827a0b311566df9231c96d6a8f1dc4c982d8ca3

4 files changed, 158 insertions, 149 deletions

diff --git a/service/jni/com_android_server_wifi_WifiNative.cpp b/service/jni/com_android_server_wifi_WifiNative.cpp
index bc775ac..2ff5c6e 100644
--- a/service/jni/com_android_server_wifi_WifiNative.cpp
+++ b/service/jni/com_android_server_wifi_WifiNative.cpp
@@ -87,7 +87,6 @@ int init_wifi_hal_func_table(wifi_hal_fn *hal_fn) {
     hal_fn->wifi_get_logger_supported_feature_set = wifi_get_logger_supported_feature_set_stub;
     hal_fn->wifi_get_ring_data = wifi_get_ring_data_stub;
     hal_fn->wifi_get_driver_version = wifi_get_driver_version_stub;
-    hal_fn->wifi_set_country_code = wifi_set_country_code;
     hal_fn->wifi_set_ssid_white_list = wifi_set_ssid_white_list;
     hal_fn->wifi_set_gscan_roam_params = wifi_set_gscan_roam_params;
     hal_fn->wifi_set_bssid_preference = wifi_set_bssid_preference;
@@ -1510,7 +1509,9 @@ static jobject android_net_wifi_get_driver_version(JNIEnv *env, jclass cls, jint
      //Need to be fixed. The memory should be allocated from lower layer
     //char *buffer = NULL;
     int buffer_length =  256;
-     char *buffer = (char *)malloc(buffer_length);
+    char *buffer = (char *)malloc(buffer_length);
+    if (!buffer) return NULL;
+    memset(buffer, 0, buffer_length);
     wifi_interface_handle handle = getIfaceHandle(env, cls, iface);
 
     ALOGD("android_net_wifi_get_driver_version = %p", handle);
@@ -1519,7 +1520,7 @@ static jobject android_net_wifi_get_driver_version(JNIEnv *env, jclass cls, jint
         return NULL;
     }
 
-    wifi_error result = hal_fn.wifi_get_driver_version(handle, &buffer, &buffer_length);
+    wifi_error result = hal_fn.wifi_get_driver_version(handle, buffer, buffer_length);
 
     if (result == WIFI_SUCCESS) {
         ALOGD("buffer is %p, length is %d", buffer, buffer_length);
@@ -1537,6 +1538,8 @@ static jobject android_net_wifi_get_firmware_version(JNIEnv *env, jclass cls, ji
     //char *buffer = NULL;
     int buffer_length = 256;
     char *buffer = (char *)malloc(buffer_length);
+    if (!buffer) return NULL;
+    memset(buffer, 0, buffer_length);
     wifi_interface_handle handle = getIfaceHandle(env, cls, iface);
 
     ALOGD("android_net_wifi_get_firmware_version = %p", handle);
@@ -1545,7 +1548,7 @@ static jobject android_net_wifi_get_firmware_version(JNIEnv *env, jclass cls, ji
         return NULL;
     }
 
-    wifi_error result = hal_fn.wifi_get_firmware_version(handle, &buffer, &buffer_length);
+    wifi_error result = hal_fn.wifi_get_firmware_version(handle, buffer, buffer_length);
 
     if (result == WIFI_SUCCESS) {
         ALOGD("buffer is %p, length is %d", buffer, buffer_length);
@@ -1572,8 +1575,9 @@ static jobject android_net_wifi_get_ring_buffer_status (JNIEnv *env, jclass cls,
     u32 num_rings = 10;
     wifi_ring_buffer_status *status =
         (wifi_ring_buffer_status *)malloc(sizeof(wifi_ring_buffer_status) * num_rings);
-
-    wifi_error result = hal_fn.wifi_get_ring_buffers_status(handle, &num_rings, &status);
+    if (!status) return NULL;
+    memset(status, 0, sizeof(wifi_ring_buffer_status) * num_rings);
+    wifi_error result = hal_fn.wifi_get_ring_buffers_status(handle, &num_rings, status);
     if (result == WIFI_SUCCESS) {
         ALOGD("status is %p, number is %d", status, num_rings);
         jclass clsRingBufferStatus =
@@ -1611,6 +1615,7 @@ static jobject android_net_wifi_get_ring_buffer_status (JNIEnv *env, jclass cls,
         free(status);
         return ringBuffersStatus;
     } else {
+        free(status);
         return NULL;
     }
 }
@@ -1841,9 +1846,9 @@ static void onPnoNetworkFound(wifi_request_id id,
         }
 
         ALOGD("Scan result with ie length %d, i %u, <%s> rssi=%d %02x:%02x:%02x:%02x:%02x:%02x",
-        results->ie_length, i,
-            results[i].ssid, results[i].rssi, results[i].bssid[0], results[i].bssid[1],
-            results[i].bssid[2], results[i].bssid[3], results[i].bssid[4], results[i].bssid[5]);
+                results->ie_length, i, results[i].ssid, results[i].rssi, results[i].bssid[0],
+                results[i].bssid[1],results[i].bssid[2], results[i].bssid[3], results[i].bssid[4],
+                results[i].bssid[5]);
 
         /*elements = env->NewByteArray(results->ie_length);
         if (elements == NULL) {
diff --git a/service/jni/wifi_hal_stub.h b/service/jni/wifi_hal_stub.h
index 67cbc27..22884c7 100644
--- a/service/jni/wifi_hal_stub.h
+++ b/service/jni/wifi_hal_stub.h
@@ -87,15 +87,15 @@ wifi_error wifi_set_log_handler_stub(wifi_request_id id, wifi_interface_handle i
         wifi_ring_buffer_data_handler handler);
 wifi_error wifi_set_alert_handler_stub(wifi_request_id id, wifi_interface_handle iface,
         wifi_alert_handler handler);
-wifi_error wifi_get_firmware_version_stub( wifi_interface_handle iface, char **buffer,
-        int *buffer_size);
+wifi_error wifi_get_firmware_version_stub(wifi_interface_handle iface, char *buffer,
+        int buffer_size);
 wifi_error wifi_get_ring_buffers_status_stub(wifi_interface_handle iface,
-        u32 *num_rings, wifi_ring_buffer_status **status);
+        u32 *num_rings, wifi_ring_buffer_status *status);
 wifi_error wifi_get_logger_supported_feature_set_stub(wifi_interface_handle iface,
         unsigned int *support);
 wifi_error wifi_get_ring_data_stub(wifi_interface_handle iface, char *ring_name);
-wifi_error wifi_get_driver_version_stub(wifi_interface_handle iface, char **buffer,
-        int *buffer_size);
+wifi_error wifi_get_driver_version_stub(wifi_interface_handle iface, char *buffer,
+        int buffer_size);
  wifi_error wifi_set_country_code_stub(wifi_interface_handle iface, const char *code);
 wifi_error wifi_set_bssid_blacklist_stub(wifi_request_id id, wifi_interface_handle iface,
         wifi_bssid_params params);
diff --git a/service/lib/wifi_hal_stub.cpp b/service/lib/wifi_hal_stub.cpp
index c9f87f9..0524ff3 100644
--- a/service/lib/wifi_hal_stub.cpp
+++ b/service/lib/wifi_hal_stub.cpp
@@ -201,13 +201,13 @@ wifi_error wifi_set_alert_handler_stub(wifi_request_id id, wifi_interface_handle
     return WIFI_ERROR_NOT_SUPPORTED;
 }
 
-wifi_error wifi_get_firmware_version_stub( wifi_interface_handle iface, char **buffer,
-        int *buffer_size) {
+wifi_error wifi_get_firmware_version_stub( wifi_interface_handle iface, char *buffer,
+        int buffer_size) {
     return WIFI_ERROR_NOT_SUPPORTED;
 }
 
 wifi_error wifi_get_ring_buffers_status_stub(wifi_interface_handle iface,
-        u32 *num_rings, wifi_ring_buffer_status **status) {
+        u32 *num_rings, wifi_ring_buffer_status *status) {
     return WIFI_ERROR_NOT_SUPPORTED;
 }
 
@@ -220,8 +220,8 @@ wifi_error wifi_get_ring_data_stub(wifi_interface_handle iface, char *ring_name)
     return WIFI_ERROR_NOT_SUPPORTED;
 }
 
-wifi_error wifi_get_driver_version_stub(wifi_interface_handle iface, char **buffer,
-        int *buffer_size) {
+wifi_error wifi_get_driver_version_stub(wifi_interface_handle iface, char *buffer,
+        int buffer_size) {
     return WIFI_ERROR_NOT_SUPPORTED;
 }
 
diff --git a/service/tools/halutil/halutil.cpp b/service/tools/halutil/halutil.cpp
index e77570f..720c87f 100644
--- a/service/tools/halutil/halutil.cpp
+++ b/service/tools/halutil/halutil.cpp
@@ -1748,125 +1748,138 @@ static void onRingBufferData(char *ring_name, char *buffer, int buffer_size,
     }
 
     /*
-     * Parsing TLV data
+     * Parsing Wake Lock event
      */
-    if (buffer_entry->type != ENTRY_TYPE_CONNECT_EVENT)
+    if (buffer_entry->type == ENTRY_TYPE_WAKE_LOCK) {
+        const char *strStatus[] = {"Taken", "Released", "Timeout"};
+        wake_lock_event *wlock_event = (wake_lock_event *) pBuff;
+
+        printMsg("Wakelock Event: Status=%s (%02x), Name=%s, Reason=%s (%02x)\n",
+            strStatus[wlock_event->status], wlock_event->status,
+            wlock_event->name, "\"TO BE\"", wlock_event->reason);
         return;
-    wifi_ring_buffer_driver_connectivity_event *connect_event =
-        (wifi_ring_buffer_driver_connectivity_event *) (pBuff);
-
-    tlv_log *tlv_data = (tlv_log *) (connect_event + 1);
-    printMsg("Event type: %s (%u)\n", RBconnectEventToString(connect_event->event),
-            connect_event->event);
-
-    char *pos = (char *)tlv_data;
-    char *end = (char *)connect_event + buffer_entry->entry_size;
-    while (pos < end) {
-        printMsg("TLV.type: %s (%02x), TLV.len=%d(%02x)\n",
-                RBTlvTagToString(tlv_data->tag),
-                tlv_data->tag, tlv_data->length, tlv_data->length);
-
-        switch (tlv_data->tag) {
-            case WIFI_TAG_VENDOR_SPECIFIC:
-                break;
+    }
 
-            case WIFI_TAG_BSSID:
-            case WIFI_TAG_ADDR:
-            case WIFI_TAG_ADDR1:
-            case WIFI_TAG_ADDR2:
-            case WIFI_TAG_ADDR3:
-            case WIFI_TAG_ADDR4:
-            {
-                if (tlv_data->length == sizeof(mac_addr)) {
-                    mac_addr addr;
-                    memcpy(&addr, tlv_data->value, sizeof(mac_addr));
-                    printMsg("Address: %02x:%02x:%02x:%02x:%02x:%02x\n",
-                        addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
-                } else
-                    printMsg("wrong lenght of address\n");
-                break;
-            }
+    /*
+     * Parsing TLV data
+     */
+    if (buffer_entry->type == ENTRY_TYPE_CONNECT_EVENT) {
+        wifi_ring_buffer_driver_connectivity_event *connect_event =
+            (wifi_ring_buffer_driver_connectivity_event *) (pBuff);
+
+        tlv_log *tlv_data = (tlv_log *) (connect_event + 1);
+        printMsg("Event type: %s (%u)\n", RBconnectEventToString(connect_event->event),
+                connect_event->event);
+
+        char *pos = (char *)tlv_data;
+        char *end = (char *)connect_event + buffer_entry->entry_size;
+        while (pos < end) {
+            printMsg("TLV.type: %s (%d), TLV.len=%d (%02x)\n",
+                    RBTlvTagToString(tlv_data->tag),
+                    tlv_data->tag, tlv_data->length, tlv_data->length);
+
+            switch (tlv_data->tag) {
+                case WIFI_TAG_VENDOR_SPECIFIC:
+                    break;
 
-            case WIFI_TAG_SSID:
-            {
-                char ssid[MAX_SSID_LEN];
-                memset(ssid, 0, sizeof(ssid));
-                if (tlv_data->length > MAX_SSID_LEN)
-                    tlv_data->length = MAX_SSID_LEN;
-                memcpy(ssid, tlv_data->value, tlv_data->length);
-                printMsg("SSID = %s\n", ssid);
-                break;
-            }
+                case WIFI_TAG_BSSID:
+                case WIFI_TAG_ADDR:
+                case WIFI_TAG_ADDR1:
+                case WIFI_TAG_ADDR2:
+                case WIFI_TAG_ADDR3:
+                case WIFI_TAG_ADDR4:
+                {
+                    if (tlv_data->length == sizeof(mac_addr)) {
+                        mac_addr addr;
+                        memcpy(&addr, tlv_data->value, sizeof(mac_addr));
+                        printMsg("Address: %02x:%02x:%02x:%02x:%02x:%02x\n",
+                            addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
+                    } else
+                        printMsg("wrong lenght of address\n");
+                    break;
+                }
 
-            case WIFI_TAG_STATUS:
-            {
-                unsigned int status = 0;
-                memcpy(&status, tlv_data->value, tlv_data->length);
-                printMsg("Status = %u\n", status);
-                break;
-            }
+                case WIFI_TAG_SSID:
+                {
+                    char ssid[MAX_SSID_LEN];
+                    memset(ssid, 0, sizeof(ssid));
+                    if (tlv_data->length > MAX_SSID_LEN)
+                        tlv_data->length = MAX_SSID_LEN;
+                    memcpy(ssid, tlv_data->value, tlv_data->length);
+                    printMsg("SSID = %s\n", ssid);
+                    break;
+                }
 
-            case WIFI_TAG_CHANNEL_SPEC:
-            {
-                wifi_channel_info *ch_spec = (wifi_channel_info *) tlv_data->value;
-                printMsg("Channel Info: center_freq=%d, freq0=%d, freq1=%d, width=%s (%d)\n",
-                    RBchanWidthToString(ch_spec->width), ch_spec->center_freq,
-                    ch_spec->center_freq0, ch_spec->center_freq1);
-                break;
-            }
+                case WIFI_TAG_STATUS:
+                {
+                    unsigned int status = 0;
+                    memcpy(&status, tlv_data->value, tlv_data->length);
+                    printMsg("Status = %u\n", status);
+                    break;
+                }
 
-            case WIFI_TAG_WAKE_LOCK_EVENT:
-            {
-                printMsg("Wake lock event = \"TO BE DONE LATER\"\n", tlv_data->value);
-                break;
-            }
+                case WIFI_TAG_CHANNEL_SPEC:
+                {
+                    wifi_channel_info *ch_spec = (wifi_channel_info *) tlv_data->value;
+                    printMsg("Channel Info: center_freq=%d, freq0=%d, freq1=%d, width=%s (%d)\n",
+                        RBchanWidthToString(ch_spec->width), ch_spec->center_freq,
+                        ch_spec->center_freq0, ch_spec->center_freq1);
+                    break;
+                }
 
-            case WIFI_TAG_TSF:
-            {
-                u64 tsf = 0;
-                memcpy(&tsf, tlv_data->value, tlv_data->length);
-                printMsg("TSF value = %d\n", tsf);
-                break;
-            }
+                case WIFI_TAG_WAKE_LOCK_EVENT:
+                {
+                    printMsg("Wake lock event = \"TO BE DONE LATER\"\n", tlv_data->value);
+                    break;
+                }
 
-            case WIFI_TAG_IE:
-            {
-                printMsg("Information Element = \"TO BE\"\n");
-                break;
-            }
+                case WIFI_TAG_TSF:
+                {
+                    u64 tsf = 0;
+                    memcpy(&tsf, tlv_data->value, tlv_data->length);
+                    printMsg("TSF value = %d\n", tsf);
+                    break;
+                }
 
-            case WIFI_TAG_INTERFACE:
-            {
-                const int len = 32;
-                char inf_name[len];
+                case WIFI_TAG_IE:
+                {
+                    printMsg("Information Element = \"TO BE\"\n");
+                    break;
+                }
 
-                if (tlv_data->length > len)
-                    tlv_data->length = len;
-                memset(inf_name, 0, 32);
-                memcpy(inf_name, tlv_data->value, tlv_data->length);
-                printMsg("Interface = %s\n", inf_name);
-                break;
-            }
+                case WIFI_TAG_INTERFACE:
+                {
+                    const int len = 32;
+                    char inf_name[len];
 
-            case WIFI_TAG_REASON_CODE:
-            {
-                u16 reason = 0;
-                memcpy(&reason, tlv_data->value, 2);
-                printMsg("Reason code = %d\n", reason);
-                break;
-            }
+                    if (tlv_data->length > len)
+                        tlv_data->length = len;
+                    memset(inf_name, 0, 32);
+                    memcpy(inf_name, tlv_data->value, tlv_data->length);
+                    printMsg("Interface = %s\n", inf_name);
+                    break;
+                }
 
-            case WIFI_TAG_RATE_MBPS:
-            {
-                u32 rate = 0;
-                memcpy(&rate, tlv_data->value, tlv_data->length);
-                printMsg("Rate = %d Kbps\n", rate);
-                break;
+                case WIFI_TAG_REASON_CODE:
+                {
+                    u16 reason = 0;
+                    memcpy(&reason, tlv_data->value, 2);
+                    printMsg("Reason code = %d\n", reason);
+                    break;
+                }
+
+                case WIFI_TAG_RATE_MBPS:
+                {
+                    u32 rate = 0;
+                    memcpy(&rate, tlv_data->value, tlv_data->length);
+                    printMsg("Rate = %.1f Mbps\n", rate * 0.5);    // rate unit is 500 Kbps.
+                    break;
+                }
             }
+            pos = (char *)(tlv_data + 1);
+            pos += tlv_data->length;
+            tlv_data = (tlv_log *) pos;
         }
-        pos = (char *)(tlv_data + 1);
-        pos += tlv_data->length;
-        tlv_data = (tlv_log *) pos;
     }
 }
 
@@ -1931,7 +1944,7 @@ static void onFirmwareMemoryDump(char *buffer, int buffer_size)
     printMsg("Write to \"%s\"\n", mem_dump_file);
     fwrite(buffer, 1, buffer_size, w_fp);
     fclose(w_fp);
-	w_fp = NULL;
+    w_fp = NULL;
 
     putEventInCache(EVENT_TYPE_LOGGER_MEMDUMP_DATA, "Memdump data");
 }
@@ -1996,64 +2009,55 @@ static wifi_error LoggerGetRingData()
 static wifi_error LoggerGetFW()
 {
     int ret;
-    int buffer_size = 256;
+    const int BSIZE = 256;
+    int buffer_size = BSIZE;
 
-    char *buffer = (char *)malloc(buffer_size);
-    if (buffer == NULL)
-        return WIFI_ERROR_OUT_OF_MEMORY;
-    memset(buffer, 0, buffer_size);
+    char buffer[BSIZE];
+    memset(buffer, 0, BSIZE);
 
-    ret = hal_fn.wifi_get_firmware_version(wlan0Handle, &buffer, &buffer_size);
+    ret = hal_fn.wifi_get_firmware_version(wlan0Handle, buffer, buffer_size);
 
     if (ret == WIFI_SUCCESS)
-        printMsg("FW version (len=%d):\n%s\n", buffer_size, buffer);
+        printMsg("FW version (len=%d):\n%s\n", strlen(buffer), buffer);
     else
         printMsg("Failed to get FW version\n");
 
-    free(buffer);
-    buffer = NULL;
-
     return WIFI_SUCCESS;
 }
 
 static wifi_error LoggerGetDriver()
 {
-    // halutil -logger -get driver
-
     int ret;
-    int buffer_size = 256;
+    const int BSIZE = 256;
+    int buffer_size = BSIZE;
 
-    char *buffer = (char *)malloc(buffer_size);
-    if (buffer == NULL)
-        return WIFI_ERROR_OUT_OF_MEMORY;
-    memset(buffer, 0, buffer_size);
+    char buffer[BSIZE];
+    memset(buffer, 0, BSIZE);
 
-    ret = hal_fn.wifi_get_driver_version(wlan0Handle, &buffer, &buffer_size);
+    ret = hal_fn.wifi_get_driver_version(wlan0Handle, buffer, buffer_size);
 
     if (ret == WIFI_SUCCESS)
-        printMsg("Driver version (len=%d):\n%s\n", buffer_size, buffer);
+        printMsg("Driver version (len=%d):\n%s\n", strlen(buffer), buffer);
     else
         printMsg("Failed to get driver version\n");
 
-    free(buffer);
-    buffer = NULL;
-
     return WIFI_SUCCESS;
 }
 
 static wifi_error LoggerGetRingbufferStatus()
 {
     int ret;
-    u32 num_rings = 10;
+    const int NRING = 10;
+    u32 num_rings = NRING;
 
     wifi_ring_buffer_status *status =
         (wifi_ring_buffer_status *)malloc(sizeof(wifi_ring_buffer_status) * num_rings);
 
     if (status == NULL)
         return WIFI_ERROR_OUT_OF_MEMORY;
-    memset(status, 0, sizeof(wifi_ring_buffer_status));
+    memset(status, 0, sizeof(wifi_ring_buffer_status) * num_rings);
 
-    ret = hal_fn.wifi_get_ring_buffers_status(wlan0Handle, &num_rings, &status);
+    ret = hal_fn.wifi_get_ring_buffers_status(wlan0Handle, &num_rings, status);
 
     if (ret == WIFI_SUCCESS) {
         printMsg("RingBuffer status: [%d ring(s)]\n", num_rings);