chpp/services/wifi_convert.c

/*
 * Copyright (C) 2020 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// This file was automatically generated by chre_api_to_chpp.py
// Date: 2020-07-08 23:38:49 UTC
// Source: chre_api/include/chre_api/chre/wifi.h @ commit 3addfee7

// DO NOT modify this file directly, as those changes will be lost the next
// time the script is executed

#include "chpp/macros.h"
#include "chpp/memory.h"
#include "chpp/services/wifi_types.h"

#include <stddef.h>
#include <stdint.h>
#include <string.h>

//! @return number of bytes required to represent the given
//! chreWifiScanEvent along with the CHPP header as
//! struct ChppWifiScanEventWithHeader
static size_t chppWifiSizeOfScanEventFromChre(
    const struct chreWifiScanEvent *scanEvent) {
  size_t encodedSize = sizeof(struct ChppWifiScanEventWithHeader);
  encodedSize += scanEvent->scannedFreqListLen * sizeof(uint32_t);
  encodedSize += scanEvent->resultCount * sizeof(struct ChppWifiScanResult);
  return encodedSize;
}

//! @return number of bytes required to represent the given
//! chreWifiScanParams along with the CHPP header as
//! struct ChppWifiScanParamsWithHeader
static size_t chppWifiSizeOfScanParamsFromChre(
    const struct chreWifiScanParams *scanParams) {
  size_t encodedSize = sizeof(struct ChppWifiScanParamsWithHeader);
  encodedSize += scanParams->frequencyListLen * sizeof(uint32_t);
  encodedSize += scanParams->ssidListLen * sizeof(struct ChppWifiSsidListItem);
  return encodedSize;
}

static void chppWifiConvertScanResultFromChre(
    const struct chreWifiScanResult *in, struct ChppWifiScanResult *out) {
  out->ageMs = in->ageMs;
  out->capabilityInfo = in->capabilityInfo;
  out->ssidLen = in->ssidLen;
  memcpy(out->ssid, in->ssid, sizeof(out->ssid));
  memcpy(out->bssid, in->bssid, sizeof(out->bssid));
  out->flags = in->flags;
  out->rssi = in->rssi;
  out->band = in->band;
  out->primaryChannel = in->primaryChannel;
  out->centerFreqPrimary = in->centerFreqPrimary;
  out->centerFreqSecondary = in->centerFreqSecondary;
  out->channelWidth = in->channelWidth;
  out->securityMode = in->securityMode;
  out->radioChain = in->radioChain;
  out->rssiChain0 = in->rssiChain0;
  out->rssiChain1 = in->rssiChain1;
  memset(&out->reserved, 0, sizeof(out->reserved));
}

static void chppWifiConvertScanEventFromChre(const struct chreWifiScanEvent *in,
                                             struct ChppWifiScanEvent *out,
                                             uint8_t *payload,
                                             size_t payloadSize,
                                             uint16_t *vlaOffset) {
  out->version = CHRE_WIFI_SCAN_EVENT_VERSION;
  out->resultCount = in->resultCount;
  out->resultTotal = in->resultTotal;
  out->eventIndex = in->eventIndex;
  out->scanType = in->scanType;
  out->ssidSetSize = in->ssidSetSize;
  out->scannedFreqListLen = in->scannedFreqListLen;
  out->referenceTime = in->referenceTime;

  uint32_t *scannedFreqList = (uint32_t *)&payload[*vlaOffset];
  out->scannedFreqList.length = in->scannedFreqListLen * sizeof(uint32_t);
  CHPP_ASSERT(*vlaOffset + out->scannedFreqList.length <= payloadSize);
  if (out->scannedFreqList.length > 0 &&
      *vlaOffset + out->scannedFreqList.length <= payloadSize) {
    out->scannedFreqList.offset = *vlaOffset;
    *vlaOffset += out->scannedFreqList.length;
    for (size_t i = 0; i < in->scannedFreqListLen; i++) {
      scannedFreqList[i] = in->scannedFreqList[i];
    }
  } else {
    out->scannedFreqList.offset = 0;
  }

  struct ChppWifiScanResult *results =
      (struct ChppWifiScanResult *)&payload[*vlaOffset];
  out->results.length = in->resultCount * sizeof(struct ChppWifiScanResult);
  CHPP_ASSERT(*vlaOffset + out->results.length <= payloadSize);
  if (out->results.length > 0 &&
      *vlaOffset + out->results.length <= payloadSize) {
    out->results.offset = *vlaOffset;
    *vlaOffset += out->results.length;
    for (size_t i = 0; i < in->resultCount; i++) {
      chppWifiConvertScanResultFromChre(&in->results[i], &results[i]);
    }
  } else {
    out->results.offset = 0;
  }
  out->radioChainPref = in->radioChainPref;
}

static void chppWifiConvertSsidListItemFromChre(
    const struct chreWifiSsidListItem *in, struct ChppWifiSsidListItem *out) {
  out->ssidLen = in->ssidLen;
  memcpy(out->ssid, in->ssid, sizeof(out->ssid));
}

static void chppWifiConvertScanParamsFromChre(
    const struct chreWifiScanParams *in, struct ChppWifiScanParams *out,
    uint8_t *payload, size_t payloadSize, uint16_t *vlaOffset) {
  out->scanType = in->scanType;
  out->maxScanAgeMs = in->maxScanAgeMs;
  out->frequencyListLen = in->frequencyListLen;

  uint32_t *frequencyList = (uint32_t *)&payload[*vlaOffset];
  out->frequencyList.length = in->frequencyListLen * sizeof(uint32_t);
  CHPP_ASSERT(*vlaOffset + out->frequencyList.length <= payloadSize);
  if (out->frequencyList.length > 0 &&
      *vlaOffset + out->frequencyList.length <= payloadSize) {
    out->frequencyList.offset = *vlaOffset;
    *vlaOffset += out->frequencyList.length;
    for (size_t i = 0; i < in->frequencyListLen; i++) {
      frequencyList[i] = in->frequencyList[i];
    }
  } else {
    out->frequencyList.offset = 0;
  }
  out->ssidListLen = in->ssidListLen;

  struct ChppWifiSsidListItem *ssidList =
      (struct ChppWifiSsidListItem *)&payload[*vlaOffset];
  out->ssidList.length = in->ssidListLen * sizeof(struct ChppWifiSsidListItem);
  CHPP_ASSERT(*vlaOffset + out->ssidList.length <= payloadSize);
  if (out->ssidList.length > 0 &&
      *vlaOffset + out->ssidList.length <= payloadSize) {
    out->ssidList.offset = *vlaOffset;
    *vlaOffset += out->ssidList.length;
    for (size_t i = 0; i < in->ssidListLen; i++) {
      chppWifiConvertSsidListItemFromChre(&in->ssidList[i], &ssidList[i]);
    }
  } else {
    out->ssidList.offset = 0;
  }
  out->radioChainPref = in->radioChainPref;
}

bool chppWifiScanEventFromChre(const struct chreWifiScanEvent *in,
                               struct ChppWifiScanEventWithHeader **out,
                               size_t *outSize) {
  CHPP_NOT_NULL(out);
  CHPP_NOT_NULL(outSize);

  size_t payloadSize = chppWifiSizeOfScanEventFromChre(in);
  *out = chppMalloc(payloadSize);
  if (*out != NULL) {
    uint8_t *payload = (uint8_t *)&(*out)->payload;
    uint16_t vlaOffset = sizeof(struct ChppWifiScanEvent);
    chppWifiConvertScanEventFromChre(in, &(*out)->payload, payload, payloadSize,
                                     &vlaOffset);
    *outSize = payloadSize;
    return true;
  }
  return false;
}

bool chppWifiScanParamsFromChre(const struct chreWifiScanParams *in,
                                struct ChppWifiScanParamsWithHeader **out,
                                size_t *outSize) {
  CHPP_NOT_NULL(out);
  CHPP_NOT_NULL(outSize);

  size_t payloadSize = chppWifiSizeOfScanParamsFromChre(in);
  *out = chppMalloc(payloadSize);
  if (*out != NULL) {
    uint8_t *payload = (uint8_t *)&(*out)->payload;
    uint16_t vlaOffset = sizeof(struct ChppWifiScanParams);
    chppWifiConvertScanParamsFromChre(in, &(*out)->payload, payload,
                                      payloadSize, &vlaOffset);
    *outSize = payloadSize;
    return true;
  }
  return false;
}