Cleanroom libnl_2 library
By overriding the netlink cache pointer, able to pass nl80211 family id.
Scan and connecting open access point work
Added legal stuff to headers
Change-Id: I1c60452f35fdd1f80edebc03fef33067722d0543
diff --git a/libnl_2/attr.c b/libnl_2/attr.c
new file mode 100644
index 0000000..11e8ae5
--- /dev/null
+++ b/libnl_2/attr.c
@@ -0,0 +1,226 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+/* NOTICE: This is a clean room re-implementation of libnl */
+
+#include <errno.h>
+#include "netlink/netlink.h"
+#include "netlink/msg.h"
+#include "netlink/attr.h"
+#include "netlink-types.h"
+
+/* Return payload of string attribute. */
+char *nla_get_string(struct nlattr *nla)
+{
+ return (char *) nla_data(nla);
+}
+
+/* Return payload of 16 bit integer attribute. */
+uint16_t nla_get_u16(struct nlattr *nla)
+{
+ return *((uint16_t *) nla_data(nla));
+}
+
+/* Return payload of 32 bit integer attribute. */
+uint32_t nla_get_u32(struct nlattr *nla)
+{
+ return *((uint32_t *) nla_data(nla));
+}
+
+/* Return value of 8 bit integer attribute. */
+uint8_t nla_get_u8(struct nlattr *nla)
+{
+ return *((uint8_t *) nla_data(nla));
+}
+
+/* Return payload of uint64_t attribute. */
+uint64_t nla_get_u64(struct nlattr *nla)
+{
+ uint64_t tmp;
+ nla_memcpy(&tmp, nla, sizeof(tmp));
+ return tmp;
+}
+
+/* Head of payload */
+void *nla_data(const struct nlattr *nla)
+{
+ return (void *) ((char *) nla + NLA_HDRLEN);
+}
+
+/* Return length of the payload . */
+int nla_len(const struct nlattr *nla)
+{
+ return nla->nla_len - NLA_HDRLEN;
+}
+
+/* Start a new level of nested attributes. */
+struct nlattr *nla_nest_start(struct nl_msg *msg, int attrtype)
+{
+ if (!nla_put(msg, attrtype, 0, NULL)) {
+ /* Get ref to last (nested start) attr */
+ int padding;
+ struct nlattr *nla;
+
+ padding = nlmsg_padlen(nlmsg_datalen(nlmsg_hdr(msg)));
+ nla = (struct nlattr *) \
+ ((char *) nlmsg_tail(msg->nm_nlh) - padding);
+ return nla;
+
+ } else
+ return NULL;
+
+}
+
+/* Finalize nesting of attributes. */
+int nla_nest_end(struct nl_msg *msg, struct nlattr *start)
+{
+ start->nla_len = (unsigned char *) \
+ nlmsg_tail(nlmsg_hdr(msg)) - (unsigned char *)start;
+ return 0;
+}
+
+/* Return next attribute in a stream of attributes. */
+struct nlattr *nla_next(const struct nlattr *nla, int *remaining)
+{
+ struct nlattr *next_nla = NULL;
+ if (nla->nla_len >= sizeof(struct nlattr) &&
+ nla->nla_len <= *remaining){
+ next_nla = (struct nlattr *) \
+ ((char *) nla + NLA_ALIGN(nla->nla_len));
+ *remaining = *remaining - NLA_ALIGN(nla->nla_len);
+ }
+
+ return next_nla;
+
+}
+
+/* Check if the attribute header and payload can be accessed safely. */
+int nla_ok(const struct nlattr *nla, int remaining)
+{
+ return remaining > 0 &&
+ nla->nla_len >= sizeof(struct nlattr) &&
+ sizeof(struct nlattr) <= (unsigned int) remaining &&
+ nla->nla_len <= remaining;
+}
+
+/* Create attribute index based on a stream of attributes. */
+/* NOTE: Policy not used ! */
+int nla_parse(struct nlattr *tb[], int maxtype, struct nlattr *head,
+ int len, struct nla_policy *policy)
+{
+ struct nlattr *pos;
+ int rem;
+
+ /* First clear table */
+ memset(tb, 0, (maxtype+1) * sizeof(struct nlattr *));
+
+ nla_for_each_attr(pos, head, len, rem) {
+ const int type = nla_type(pos);
+
+ if (type <= maxtype)
+ tb[type] = pos;
+
+ }
+
+ return 0;
+}
+
+
+/* Create attribute index based on nested attribute. */
+int nla_parse_nested(struct nlattr *tb[], int maxtype,
+ struct nlattr *nla, struct nla_policy *policy)
+{
+ return nla_parse(tb, maxtype, nla_data(nla), nla_len(nla), policy);
+}
+
+
+/* Add a unspecific attribute to netlink message. */
+int nla_put(struct nl_msg *msg, int attrtype, int datalen, const void *data)
+{
+ struct nlattr *nla;
+
+ /* Reserve space and init nla header */
+ nla = nla_reserve(msg, attrtype, datalen);
+ if (nla)
+ memcpy(nla_data(nla), data, datalen);
+
+ return -errno;
+
+}
+
+
+/* Add nested attributes to netlink message. */
+/* Takes the attributes found in the nested message and appends them
+ * to the message msg nested in a container of the type attrtype. The
+ * nested message may not have a family specific header */
+int nla_put_nested(struct nl_msg *msg, int attrtype, struct nl_msg *nested)
+{
+ int rc = -1;
+ const int NO_HEADER = 0;
+
+ rc = nla_put(
+ msg,
+ attrtype,
+ nlmsg_attrlen(nlmsg_hdr(nested), NO_HEADER),
+ (const void *) nlmsg_attrdata(nlmsg_hdr(nested), NO_HEADER)
+ );
+ return rc;
+
+}
+
+/* Return type of the attribute. */
+int nla_type(const struct nlattr *nla)
+{
+ return (int) nla->nla_type;
+}
+
+/* Reserves room for an attribute in specified netlink message and fills
+ * in the attribute header (type,length). Return NULL if insufficient space */
+struct nlattr *nla_reserve(struct nl_msg * msg, int attrtype, int data_len)
+{
+
+ struct nlattr *nla;
+ const unsigned int NEW_SIZE = \
+ msg->nm_nlh->nlmsg_len + NLA_ALIGN(NLA_HDRLEN + data_len);
+
+ /* Check enough space for attribute */
+ if (NEW_SIZE <= msg->nm_size) {
+ const int fam_hdrlen = msg->nm_nlh->nlmsg_len - NLMSG_HDRLEN;
+ msg->nm_nlh->nlmsg_len = NEW_SIZE;
+ nla = nlmsg_attrdata(msg->nm_nlh, fam_hdrlen);
+ nla->nla_type = attrtype;
+ nla->nla_len = NLA_HDRLEN + data_len;
+ } else
+ goto fail;
+
+ return nla;
+fail:
+ return NULL;
+
+}
+
+/* Copy attribute payload to another memory area. */
+int nla_memcpy(void *dest, struct nlattr *src, int count)
+{
+ int rc;
+ void *ret_dest = memcpy(dest, nla_data(src), count);
+ if (!ret_dest)
+ return count;
+ else
+ return 0;
+}
+
+