Paul Cercueil / libiio

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependencies:   libserialport libxml2

context.c@3:d147beabba0e, 2017-01-30 (annotated)

Committer:
pcercuei
Date:
Mon Jan 30 13:00:39 2017 +0000
Revision:
3:d147beabba0e
Parent:
2:9eb0a9a1f958
Child:
4:ad69b39bf124
Update to libiio v0.9

Who changed what in which revision?

UserRevisionLine numberNew contents of line
pcercuei 0:df031b60ca29 1 /*
pcercuei 0:df031b60ca29 2 * libiio - Library for interfacing industrial I/O (IIO) devices
pcercuei 0:df031b60ca29 3 *
pcercuei 0:df031b60ca29 4 * Copyright (C) 2014 Analog Devices, Inc.
pcercuei 0:df031b60ca29 5 * Author: Paul Cercueil <paul.cercueil@analog.com>
pcercuei 0:df031b60ca29 6 *
pcercuei 0:df031b60ca29 7 * This library is free software; you can redistribute it and/or
pcercuei 0:df031b60ca29 8 * modify it under the terms of the GNU Lesser General Public
pcercuei 0:df031b60ca29 9 * License as published by the Free Software Foundation; either
pcercuei 0:df031b60ca29 10 * version 2.1 of the License, or (at your option) any later version.
pcercuei 0:df031b60ca29 11 *
pcercuei 0:df031b60ca29 12 * This library is distributed in the hope that it will be useful,
pcercuei 0:df031b60ca29 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
pcercuei 0:df031b60ca29 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
pcercuei 0:df031b60ca29 15 * Lesser General Public License for more details.
pcercuei 0:df031b60ca29 16 *
pcercuei 0:df031b60ca29 17 * */
pcercuei 0:df031b60ca29 18
pcercuei 0:df031b60ca29 19 #include "debug.h"
pcercuei 0:df031b60ca29 20 #include "iio-config.h"
pcercuei 0:df031b60ca29 21 #include "iio-private.h"
pcercuei 0:df031b60ca29 22
pcercuei 2:9eb0a9a1f958 23 #include <errno.h>
pcercuei 0:df031b60ca29 24 #include <string.h>
pcercuei 0:df031b60ca29 25
pcercuei 0:df031b60ca29 26 #ifdef _WIN32
pcercuei 0:df031b60ca29 27 #define LOCAL_BACKEND 0
pcercuei 0:df031b60ca29 28 #define NETWORK_BACKEND 1
pcercuei 0:df031b60ca29 29 #endif
pcercuei 0:df031b60ca29 30
pcercuei 0:df031b60ca29 31 static const char xml_header[] = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
pcercuei 0:df031b60ca29 32 "<!DOCTYPE context ["
pcercuei 3:d147beabba0e 33 "<!ELEMENT context (device | context-attribute)*>"
pcercuei 3:d147beabba0e 34 "<!ELEMENT context-attribute EMPTY>"
pcercuei 0:df031b60ca29 35 "<!ELEMENT device (channel | attribute | debug-attribute)*>"
pcercuei 0:df031b60ca29 36 "<!ELEMENT channel (scan-element?, attribute*)>"
pcercuei 0:df031b60ca29 37 "<!ELEMENT attribute EMPTY>"
pcercuei 0:df031b60ca29 38 "<!ELEMENT scan-element EMPTY>"
pcercuei 0:df031b60ca29 39 "<!ELEMENT debug-attribute EMPTY>"
pcercuei 0:df031b60ca29 40 "<!ATTLIST context name CDATA #REQUIRED description CDATA #IMPLIED>"
pcercuei 3:d147beabba0e 41 "<!ATTLIST context-attribute name CDATA #REQUIRED value CDATA #REQUIRED>"
pcercuei 0:df031b60ca29 42 "<!ATTLIST device id CDATA #REQUIRED name CDATA #IMPLIED>"
pcercuei 0:df031b60ca29 43 "<!ATTLIST channel id CDATA #REQUIRED type (input|output) #REQUIRED name CDATA #IMPLIED>"
pcercuei 0:df031b60ca29 44 "<!ATTLIST scan-element index CDATA #REQUIRED format CDATA #REQUIRED scale CDATA #IMPLIED>"
pcercuei 0:df031b60ca29 45 "<!ATTLIST attribute name CDATA #REQUIRED filename CDATA #IMPLIED>"
pcercuei 0:df031b60ca29 46 "<!ATTLIST debug-attribute name CDATA #REQUIRED>"
pcercuei 0:df031b60ca29 47 "]>";
pcercuei 0:df031b60ca29 48
pcercuei 0:df031b60ca29 49 /* Returns a string containing the XML representation of this context */
pcercuei 0:df031b60ca29 50 char * iio_context_create_xml(const struct iio_context *ctx)
pcercuei 0:df031b60ca29 51 {
pcercuei 3:d147beabba0e 52 size_t len, *devices_len = NULL;
pcercuei 3:d147beabba0e 53 char *str, *ptr, **devices = NULL;
pcercuei 0:df031b60ca29 54 unsigned int i;
pcercuei 0:df031b60ca29 55
pcercuei 0:df031b60ca29 56 len = strlen(ctx->name) + sizeof(xml_header) - 1 +
pcercuei 0:df031b60ca29 57 sizeof("<context name=\"\" ></context>");
pcercuei 0:df031b60ca29 58 if (ctx->description)
pcercuei 0:df031b60ca29 59 len += strlen(ctx->description) +
pcercuei 0:df031b60ca29 60 sizeof(" description=\"\"") - 1;
pcercuei 0:df031b60ca29 61
pcercuei 3:d147beabba0e 62 for (i = 0; i < ctx->nb_attrs; i++)
pcercuei 3:d147beabba0e 63 len += strlen(ctx->attrs[i]) +
pcercuei 3:d147beabba0e 64 strlen(ctx->values[i]) +
pcercuei 3:d147beabba0e 65 sizeof("<context-attribute name=\"\" value=\"\" />");
pcercuei 3:d147beabba0e 66
pcercuei 3:d147beabba0e 67 if (ctx->nb_devices) {
pcercuei 3:d147beabba0e 68 devices_len = malloc(ctx->nb_devices * sizeof(*devices_len));
pcercuei 3:d147beabba0e 69 if (!devices_len) {
pcercuei 0:df031b60ca29 70 errno = ENOMEM;
pcercuei 0:df031b60ca29 71 return NULL;
pcercuei 0:df031b60ca29 72 }
pcercuei 0:df031b60ca29 73
pcercuei 3:d147beabba0e 74 devices = malloc(ctx->nb_devices * sizeof(*devices));
pcercuei 3:d147beabba0e 75 if (!devices)
pcercuei 3:d147beabba0e 76 goto err_free_devices_len;
pcercuei 0:df031b60ca29 77
pcercuei 3:d147beabba0e 78 for (i = 0; i < ctx->nb_devices; i++) {
pcercuei 3:d147beabba0e 79 char *xml = iio_device_get_xml(ctx->devices[i],
pcercuei 3:d147beabba0e 80 &devices_len[i]);
pcercuei 3:d147beabba0e 81 if (!xml)
pcercuei 3:d147beabba0e 82 goto err_free_devices;
pcercuei 3:d147beabba0e 83 devices[i] = xml;
pcercuei 3:d147beabba0e 84 len += devices_len[i];
pcercuei 3:d147beabba0e 85 }
pcercuei 0:df031b60ca29 86 }
pcercuei 0:df031b60ca29 87
pcercuei 0:df031b60ca29 88 str = malloc(len);
pcercuei 0:df031b60ca29 89 if (!str) {
pcercuei 0:df031b60ca29 90 errno = ENOMEM;
pcercuei 0:df031b60ca29 91 goto err_free_devices;
pcercuei 0:df031b60ca29 92 }
pcercuei 0:df031b60ca29 93
pcercuei 3:d147beabba0e 94 if (ctx->description) {
pcercuei 3:d147beabba0e 95 iio_snprintf(str, len, "%s<context name=\"%s\" "
pcercuei 0:df031b60ca29 96 "description=\"%s\" >",
pcercuei 0:df031b60ca29 97 xml_header, ctx->name, ctx->description);
pcercuei 3:d147beabba0e 98 } else {
pcercuei 3:d147beabba0e 99 iio_snprintf(str, len, "%s<context name=\"%s\" >",
pcercuei 0:df031b60ca29 100 xml_header, ctx->name);
pcercuei 3:d147beabba0e 101 }
pcercuei 3:d147beabba0e 102
pcercuei 0:df031b60ca29 103 ptr = strrchr(str, '\0');
pcercuei 0:df031b60ca29 104
pcercuei 3:d147beabba0e 105 for (i = 0; i < ctx->nb_attrs; i++)
pcercuei 3:d147beabba0e 106 ptr += sprintf(ptr, "<context-attribute name=\"%s\" value=\"%s\" />",
pcercuei 3:d147beabba0e 107 ctx->attrs[i], ctx->values[i]);
pcercuei 3:d147beabba0e 108
pcercuei 3:d147beabba0e 109
pcercuei 0:df031b60ca29 110 for (i = 0; i < ctx->nb_devices; i++) {
pcercuei 0:df031b60ca29 111 strcpy(ptr, devices[i]);
pcercuei 0:df031b60ca29 112 ptr += devices_len[i];
pcercuei 0:df031b60ca29 113 free(devices[i]);
pcercuei 0:df031b60ca29 114 }
pcercuei 0:df031b60ca29 115
pcercuei 0:df031b60ca29 116 free(devices);
pcercuei 0:df031b60ca29 117 free(devices_len);
pcercuei 0:df031b60ca29 118 strcpy(ptr, "</context>");
pcercuei 0:df031b60ca29 119 return str;
pcercuei 0:df031b60ca29 120
pcercuei 0:df031b60ca29 121 err_free_devices:
pcercuei 0:df031b60ca29 122 while (i--)
pcercuei 0:df031b60ca29 123 free(devices[i]);
pcercuei 0:df031b60ca29 124 free(devices);
pcercuei 0:df031b60ca29 125 err_free_devices_len:
pcercuei 0:df031b60ca29 126 free(devices_len);
pcercuei 0:df031b60ca29 127 return NULL;
pcercuei 0:df031b60ca29 128 }
pcercuei 0:df031b60ca29 129
pcercuei 0:df031b60ca29 130 const char * iio_context_get_xml(const struct iio_context *ctx)
pcercuei 0:df031b60ca29 131 {
pcercuei 0:df031b60ca29 132 return ctx->xml;
pcercuei 0:df031b60ca29 133 }
pcercuei 0:df031b60ca29 134
pcercuei 0:df031b60ca29 135 const char * iio_context_get_name(const struct iio_context *ctx)
pcercuei 0:df031b60ca29 136 {
pcercuei 0:df031b60ca29 137 return ctx->name;
pcercuei 0:df031b60ca29 138 }
pcercuei 0:df031b60ca29 139
pcercuei 0:df031b60ca29 140 const char * iio_context_get_description(const struct iio_context *ctx)
pcercuei 0:df031b60ca29 141 {
pcercuei 0:df031b60ca29 142 if (ctx->description)
pcercuei 0:df031b60ca29 143 return ctx->description;
pcercuei 0:df031b60ca29 144 else
pcercuei 0:df031b60ca29 145 return "";
pcercuei 0:df031b60ca29 146 }
pcercuei 0:df031b60ca29 147
pcercuei 0:df031b60ca29 148 void iio_context_destroy(struct iio_context *ctx)
pcercuei 0:df031b60ca29 149 {
pcercuei 0:df031b60ca29 150 unsigned int i;
pcercuei 0:df031b60ca29 151 if (ctx->ops->shutdown)
pcercuei 0:df031b60ca29 152 ctx->ops->shutdown(ctx);
pcercuei 0:df031b60ca29 153
pcercuei 3:d147beabba0e 154 for (i = 0; i < ctx->nb_attrs; i++) {
pcercuei 3:d147beabba0e 155 free(ctx->attrs[i]);
pcercuei 3:d147beabba0e 156 free(ctx->values[i]);
pcercuei 3:d147beabba0e 157 }
pcercuei 3:d147beabba0e 158 if (ctx->nb_attrs) {
pcercuei 3:d147beabba0e 159 free(ctx->attrs);
pcercuei 3:d147beabba0e 160 free(ctx->values);
pcercuei 3:d147beabba0e 161 }
pcercuei 0:df031b60ca29 162 for (i = 0; i < ctx->nb_devices; i++)
pcercuei 0:df031b60ca29 163 free_device(ctx->devices[i]);
pcercuei 0:df031b60ca29 164 if (ctx->nb_devices)
pcercuei 0:df031b60ca29 165 free(ctx->devices);
pcercuei 0:df031b60ca29 166 if (ctx->xml)
pcercuei 0:df031b60ca29 167 free(ctx->xml);
pcercuei 0:df031b60ca29 168 if (ctx->description)
pcercuei 0:df031b60ca29 169 free(ctx->description);
pcercuei 0:df031b60ca29 170 free(ctx);
pcercuei 0:df031b60ca29 171 }
pcercuei 0:df031b60ca29 172
pcercuei 0:df031b60ca29 173 unsigned int iio_context_get_devices_count(const struct iio_context *ctx)
pcercuei 0:df031b60ca29 174 {
pcercuei 0:df031b60ca29 175 return ctx->nb_devices;
pcercuei 0:df031b60ca29 176 }
pcercuei 0:df031b60ca29 177
pcercuei 0:df031b60ca29 178 struct iio_device * iio_context_get_device(const struct iio_context *ctx,
pcercuei 0:df031b60ca29 179 unsigned int index)
pcercuei 0:df031b60ca29 180 {
pcercuei 0:df031b60ca29 181 if (index >= ctx->nb_devices)
pcercuei 0:df031b60ca29 182 return NULL;
pcercuei 0:df031b60ca29 183 else
pcercuei 0:df031b60ca29 184 return ctx->devices[index];
pcercuei 0:df031b60ca29 185 }
pcercuei 0:df031b60ca29 186
pcercuei 0:df031b60ca29 187 struct iio_device * iio_context_find_device(const struct iio_context *ctx,
pcercuei 0:df031b60ca29 188 const char *name)
pcercuei 0:df031b60ca29 189 {
pcercuei 0:df031b60ca29 190 unsigned int i;
pcercuei 0:df031b60ca29 191 for (i = 0; i < ctx->nb_devices; i++) {
pcercuei 0:df031b60ca29 192 struct iio_device *dev = ctx->devices[i];
pcercuei 0:df031b60ca29 193 if (!strcmp(dev->id, name) ||
pcercuei 0:df031b60ca29 194 (dev->name && !strcmp(dev->name, name)))
pcercuei 0:df031b60ca29 195 return dev;
pcercuei 0:df031b60ca29 196 }
pcercuei 0:df031b60ca29 197 return NULL;
pcercuei 0:df031b60ca29 198 }
pcercuei 0:df031b60ca29 199
pcercuei 0:df031b60ca29 200 static void reorder_channels(struct iio_device *dev)
pcercuei 0:df031b60ca29 201 {
pcercuei 0:df031b60ca29 202 bool found;
pcercuei 0:df031b60ca29 203 unsigned int i;
pcercuei 0:df031b60ca29 204
pcercuei 0:df031b60ca29 205 /* Reorder channels by index */
pcercuei 0:df031b60ca29 206 do {
pcercuei 0:df031b60ca29 207 found = false;
pcercuei 0:df031b60ca29 208 for (i = 1; i < dev->nb_channels; i++) {
pcercuei 0:df031b60ca29 209 struct iio_channel **channels = dev->channels;
pcercuei 0:df031b60ca29 210 long ch1 = channels[i - 1]->index;
pcercuei 0:df031b60ca29 211 long ch2 = channels[i]->index;
pcercuei 0:df031b60ca29 212
pcercuei 0:df031b60ca29 213 if (ch1 == ch2 && ch1 >= 0) {
pcercuei 0:df031b60ca29 214 ch1 = channels[i - 1]->format.shift;
pcercuei 0:df031b60ca29 215 ch2 = channels[i]->format.shift;
pcercuei 0:df031b60ca29 216 }
pcercuei 0:df031b60ca29 217
pcercuei 0:df031b60ca29 218 if (ch2 >= 0 && ((ch1 > ch2) || ch1 < 0)) {
pcercuei 0:df031b60ca29 219 struct iio_channel *bak = channels[i];
pcercuei 0:df031b60ca29 220 channels[i] = channels[i - 1];
pcercuei 0:df031b60ca29 221 channels[i - 1] = bak;
pcercuei 0:df031b60ca29 222 found = true;
pcercuei 0:df031b60ca29 223 }
pcercuei 0:df031b60ca29 224 }
pcercuei 0:df031b60ca29 225 } while (found);
pcercuei 0:df031b60ca29 226 }
pcercuei 0:df031b60ca29 227
pcercuei 0:df031b60ca29 228 int iio_context_init(struct iio_context *ctx)
pcercuei 0:df031b60ca29 229 {
pcercuei 0:df031b60ca29 230 unsigned int i;
pcercuei 0:df031b60ca29 231
pcercuei 0:df031b60ca29 232 for (i = 0; i < ctx->nb_devices; i++)
pcercuei 0:df031b60ca29 233 reorder_channels(ctx->devices[i]);
pcercuei 0:df031b60ca29 234
pcercuei 0:df031b60ca29 235 if (!ctx->xml) {
pcercuei 0:df031b60ca29 236 ctx->xml = iio_context_create_xml(ctx);
pcercuei 0:df031b60ca29 237 if (!ctx->xml)
pcercuei 0:df031b60ca29 238 return -ENOMEM;
pcercuei 0:df031b60ca29 239 }
pcercuei 0:df031b60ca29 240
pcercuei 0:df031b60ca29 241 return 0;
pcercuei 0:df031b60ca29 242 }
pcercuei 0:df031b60ca29 243
pcercuei 0:df031b60ca29 244 int iio_context_get_version(const struct iio_context *ctx,
pcercuei 0:df031b60ca29 245 unsigned int *major, unsigned int *minor, char git_tag[8])
pcercuei 0:df031b60ca29 246 {
pcercuei 0:df031b60ca29 247 if (ctx->ops->get_version)
pcercuei 0:df031b60ca29 248 return ctx->ops->get_version(ctx, major, minor, git_tag);
pcercuei 0:df031b60ca29 249
pcercuei 0:df031b60ca29 250 iio_library_get_version(major, minor, git_tag);
pcercuei 0:df031b60ca29 251 return 0;
pcercuei 0:df031b60ca29 252 }
pcercuei 0:df031b60ca29 253
pcercuei 0:df031b60ca29 254 int iio_context_set_timeout(struct iio_context *ctx, unsigned int timeout)
pcercuei 0:df031b60ca29 255 {
pcercuei 0:df031b60ca29 256 if (ctx->ops->set_timeout)
pcercuei 0:df031b60ca29 257 return ctx->ops->set_timeout(ctx, timeout);
pcercuei 0:df031b60ca29 258 else
pcercuei 0:df031b60ca29 259 return -ENOSYS;
pcercuei 0:df031b60ca29 260 }
pcercuei 0:df031b60ca29 261
pcercuei 0:df031b60ca29 262 struct iio_context * iio_context_clone(const struct iio_context *ctx)
pcercuei 0:df031b60ca29 263 {
pcercuei 0:df031b60ca29 264 if (ctx->ops->clone) {
pcercuei 0:df031b60ca29 265 return ctx->ops->clone(ctx);
pcercuei 0:df031b60ca29 266 } else {
pcercuei 0:df031b60ca29 267 errno = ENOSYS;
pcercuei 0:df031b60ca29 268 return NULL;
pcercuei 0:df031b60ca29 269 }
pcercuei 0:df031b60ca29 270 }
pcercuei 0:df031b60ca29 271
pcercuei 0:df031b60ca29 272 struct iio_context * iio_create_context_from_uri(const char *uri)
pcercuei 0:df031b60ca29 273 {
pcercuei 0:df031b60ca29 274 #ifdef WITH_LOCAL_BACKEND
pcercuei 0:df031b60ca29 275 if (strcmp(uri, "local:") == 0) /* No address part */
pcercuei 0:df031b60ca29 276 return iio_create_local_context();
pcercuei 0:df031b60ca29 277 #endif
pcercuei 0:df031b60ca29 278
pcercuei 0:df031b60ca29 279 #ifdef WITH_XML_BACKEND
pcercuei 0:df031b60ca29 280 if (strncmp(uri, "xml:", sizeof("xml:") - 1) == 0)
pcercuei 0:df031b60ca29 281 return iio_create_xml_context(uri + sizeof("xml:") - 1);
pcercuei 0:df031b60ca29 282 #endif
pcercuei 0:df031b60ca29 283
pcercuei 0:df031b60ca29 284 #ifdef WITH_NETWORK_BACKEND
pcercuei 0:df031b60ca29 285 if (strncmp(uri, "ip:", sizeof("ip:") - 1) == 0)
pcercuei 0:df031b60ca29 286 return iio_create_network_context(uri+3);
pcercuei 0:df031b60ca29 287 #endif
pcercuei 0:df031b60ca29 288
pcercuei 0:df031b60ca29 289 #ifdef WITH_USB_BACKEND
pcercuei 0:df031b60ca29 290 if (strncmp(uri, "usb:", sizeof("usb:") - 1) == 0)
pcercuei 0:df031b60ca29 291 return usb_create_context_from_uri(uri);
pcercuei 0:df031b60ca29 292 #endif
pcercuei 0:df031b60ca29 293
pcercuei 0:df031b60ca29 294 #ifdef WITH_SERIAL_BACKEND
pcercuei 0:df031b60ca29 295 if (strncmp(uri, "serial:", sizeof("serial:") - 1) == 0)
pcercuei 0:df031b60ca29 296 return serial_create_context_from_uri(uri);
pcercuei 0:df031b60ca29 297 #endif
pcercuei 0:df031b60ca29 298
pcercuei 0:df031b60ca29 299 errno = ENOSYS;
pcercuei 0:df031b60ca29 300 return NULL;
pcercuei 0:df031b60ca29 301 }
pcercuei 0:df031b60ca29 302
pcercuei 0:df031b60ca29 303 struct iio_context * iio_create_default_context(void)
pcercuei 0:df031b60ca29 304 {
pcercuei 0:df031b60ca29 305 char *hostname = getenv("IIOD_REMOTE");
pcercuei 0:df031b60ca29 306
pcercuei 0:df031b60ca29 307 if (hostname) {
pcercuei 0:df031b60ca29 308 struct iio_context *ctx;
pcercuei 0:df031b60ca29 309
pcercuei 0:df031b60ca29 310 ctx = iio_create_context_from_uri(hostname);
pcercuei 0:df031b60ca29 311 if (ctx)
pcercuei 0:df031b60ca29 312 return ctx;
pcercuei 0:df031b60ca29 313
pcercuei 0:df031b60ca29 314 #ifdef WITH_NETWORK_BACKEND
pcercuei 0:df031b60ca29 315 /* If the environment variable is an empty string, we will
pcercuei 0:df031b60ca29 316 * discover the server using ZeroConf */
pcercuei 0:df031b60ca29 317 if (strlen(hostname) == 0)
pcercuei 0:df031b60ca29 318 hostname = NULL;
pcercuei 0:df031b60ca29 319
pcercuei 0:df031b60ca29 320 return iio_create_network_context(hostname);
pcercuei 0:df031b60ca29 321 #endif
pcercuei 0:df031b60ca29 322 }
pcercuei 0:df031b60ca29 323
pcercuei 0:df031b60ca29 324 return iio_create_local_context();
pcercuei 0:df031b60ca29 325 }
pcercuei 0:df031b60ca29 326
pcercuei 0:df031b60ca29 327 struct iio_context * iio_create_local_context(void)
pcercuei 0:df031b60ca29 328 {
pcercuei 0:df031b60ca29 329 #ifdef WITH_LOCAL_BACKEND
pcercuei 0:df031b60ca29 330 return local_create_context();
pcercuei 0:df031b60ca29 331 #else
pcercuei 0:df031b60ca29 332 errno = ENOSYS;
pcercuei 0:df031b60ca29 333 return NULL;
pcercuei 0:df031b60ca29 334 #endif
pcercuei 0:df031b60ca29 335 }
pcercuei 0:df031b60ca29 336
pcercuei 0:df031b60ca29 337 struct iio_context * iio_create_network_context(const char *hostname)
pcercuei 0:df031b60ca29 338 {
pcercuei 0:df031b60ca29 339 #ifdef WITH_NETWORK_BACKEND
pcercuei 0:df031b60ca29 340 return network_create_context(hostname);
pcercuei 0:df031b60ca29 341 #else
pcercuei 0:df031b60ca29 342 errno = ENOSYS;
pcercuei 0:df031b60ca29 343 return NULL;
pcercuei 0:df031b60ca29 344 #endif
pcercuei 0:df031b60ca29 345 }
pcercuei 0:df031b60ca29 346
pcercuei 0:df031b60ca29 347 struct iio_context * iio_create_xml_context_mem(const char *xml, size_t len)
pcercuei 0:df031b60ca29 348 {
pcercuei 0:df031b60ca29 349 #ifdef WITH_XML_BACKEND
pcercuei 0:df031b60ca29 350 return xml_create_context_mem(xml, len);
pcercuei 0:df031b60ca29 351 #else
pcercuei 0:df031b60ca29 352 errno = ENOSYS;
pcercuei 0:df031b60ca29 353 return NULL;
pcercuei 0:df031b60ca29 354 #endif
pcercuei 0:df031b60ca29 355 }
pcercuei 0:df031b60ca29 356
pcercuei 0:df031b60ca29 357 struct iio_context * iio_create_xml_context(const char *xml_file)
pcercuei 0:df031b60ca29 358 {
pcercuei 0:df031b60ca29 359 #ifdef WITH_XML_BACKEND
pcercuei 0:df031b60ca29 360 return xml_create_context(xml_file);
pcercuei 0:df031b60ca29 361 #else
pcercuei 0:df031b60ca29 362 errno = ENOSYS;
pcercuei 0:df031b60ca29 363 return NULL;
pcercuei 0:df031b60ca29 364 #endif
pcercuei 0:df031b60ca29 365 }
pcercuei 3:d147beabba0e 366
pcercuei 3:d147beabba0e 367 unsigned int iio_context_get_attrs_count(const struct iio_context *ctx)
pcercuei 3:d147beabba0e 368 {
pcercuei 3:d147beabba0e 369 return ctx->nb_attrs;
pcercuei 3:d147beabba0e 370 }
pcercuei 3:d147beabba0e 371
pcercuei 3:d147beabba0e 372 int iio_context_get_attr(const struct iio_context *ctx, unsigned int index,
pcercuei 3:d147beabba0e 373 const char **name, const char **value)
pcercuei 3:d147beabba0e 374 {
pcercuei 3:d147beabba0e 375 if (index >= ctx->nb_attrs)
pcercuei 3:d147beabba0e 376 return -EINVAL;
pcercuei 3:d147beabba0e 377
pcercuei 3:d147beabba0e 378 if (name)
pcercuei 3:d147beabba0e 379 *name = ctx->attrs[index];
pcercuei 3:d147beabba0e 380 if (value)
pcercuei 3:d147beabba0e 381 *value = ctx->values[index];
pcercuei 3:d147beabba0e 382 return 0;
pcercuei 3:d147beabba0e 383 }
pcercuei 3:d147beabba0e 384
pcercuei 3:d147beabba0e 385 const char * iio_context_get_attr_value(
pcercuei 3:d147beabba0e 386 const struct iio_context *ctx, const char *name)
pcercuei 3:d147beabba0e 387 {
pcercuei 3:d147beabba0e 388 unsigned int i;
pcercuei 3:d147beabba0e 389
pcercuei 3:d147beabba0e 390 for (i = 0; i < ctx->nb_attrs; i++) {
pcercuei 3:d147beabba0e 391 if (!strcmp(name, ctx->attrs[i]))
pcercuei 3:d147beabba0e 392 return ctx->values[i];
pcercuei 3:d147beabba0e 393 }
pcercuei 3:d147beabba0e 394
pcercuei 3:d147beabba0e 395 return NULL;
pcercuei 3:d147beabba0e 396 }
pcercuei 3:d147beabba0e 397
pcercuei 3:d147beabba0e 398 int iio_context_add_attr(struct iio_context *ctx,
pcercuei 3:d147beabba0e 399 const char *key, const char *value)
pcercuei 3:d147beabba0e 400 {
pcercuei 3:d147beabba0e 401 char **attrs, **values, *new_key, *new_val;
pcercuei 3:d147beabba0e 402
pcercuei 3:d147beabba0e 403 attrs = realloc(ctx->attrs,
pcercuei 3:d147beabba0e 404 (ctx->nb_attrs + 1) * sizeof(*ctx->attrs));
pcercuei 3:d147beabba0e 405 if (!attrs)
pcercuei 3:d147beabba0e 406 return -ENOMEM;
pcercuei 3:d147beabba0e 407
pcercuei 3:d147beabba0e 408 ctx->attrs = attrs;
pcercuei 3:d147beabba0e 409
pcercuei 3:d147beabba0e 410 values = realloc(ctx->values,
pcercuei 3:d147beabba0e 411 (ctx->nb_attrs + 1) * sizeof(*ctx->values));
pcercuei 3:d147beabba0e 412 if (!values)
pcercuei 3:d147beabba0e 413 return -ENOMEM;
pcercuei 3:d147beabba0e 414
pcercuei 3:d147beabba0e 415 ctx->values = values;
pcercuei 3:d147beabba0e 416
pcercuei 3:d147beabba0e 417 new_key = iio_strdup(key);
pcercuei 3:d147beabba0e 418 if (!new_key)
pcercuei 3:d147beabba0e 419 return -ENOMEM;
pcercuei 3:d147beabba0e 420
pcercuei 3:d147beabba0e 421 new_val = iio_strdup(value);
pcercuei 3:d147beabba0e 422 if (!new_val) {
pcercuei 3:d147beabba0e 423 free(new_key);
pcercuei 3:d147beabba0e 424 return -ENOMEM;
pcercuei 3:d147beabba0e 425 }
pcercuei 3:d147beabba0e 426
pcercuei 3:d147beabba0e 427 ctx->attrs[ctx->nb_attrs] = new_key;
pcercuei 3:d147beabba0e 428 ctx->values[ctx->nb_attrs] = new_val;
pcercuei 3:d147beabba0e 429 ctx->nb_attrs++;
pcercuei 3:d147beabba0e 430 return 0;
pcercuei 3:d147beabba0e 431 }
pcercuei 0:df031b60ca29 432