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@4:ad69b39bf124, 2017-06-26 (annotated)

Committer:
pcercuei
Date:
Mon Jun 26 14:30:10 2017 +0000
Revision:
4:ad69b39bf124
Parent:
3:d147beabba0e 
Update to upstream version v0.10

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 4:ad69b39bf124 74 devices = calloc(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 4:ad69b39bf124 122 for (i = 0; i < ctx->nb_devices; 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 4:ad69b39bf124 226
pcercuei 4:ad69b39bf124 227 for (i = 0; i < dev->nb_channels; i++)
pcercuei 4:ad69b39bf124 228 dev->channels[i]->number = i;
pcercuei 0:df031b60ca29 229 }
pcercuei 0:df031b60ca29 230
pcercuei 0:df031b60ca29 231 int iio_context_init(struct iio_context *ctx)
pcercuei 0:df031b60ca29 232 {
pcercuei 0:df031b60ca29 233 unsigned int i;
pcercuei 0:df031b60ca29 234
pcercuei 0:df031b60ca29 235 for (i = 0; i < ctx->nb_devices; i++)
pcercuei 0:df031b60ca29 236 reorder_channels(ctx->devices[i]);
pcercuei 0:df031b60ca29 237
pcercuei 0:df031b60ca29 238 if (!ctx->xml) {
pcercuei 0:df031b60ca29 239 ctx->xml = iio_context_create_xml(ctx);
pcercuei 0:df031b60ca29 240 if (!ctx->xml)
pcercuei 0:df031b60ca29 241 return -ENOMEM;
pcercuei 0:df031b60ca29 242 }
pcercuei 0:df031b60ca29 243
pcercuei 0:df031b60ca29 244 return 0;
pcercuei 0:df031b60ca29 245 }
pcercuei 0:df031b60ca29 246
pcercuei 0:df031b60ca29 247 int iio_context_get_version(const struct iio_context *ctx,
pcercuei 0:df031b60ca29 248 unsigned int *major, unsigned int *minor, char git_tag[8])
pcercuei 0:df031b60ca29 249 {
pcercuei 0:df031b60ca29 250 if (ctx->ops->get_version)
pcercuei 0:df031b60ca29 251 return ctx->ops->get_version(ctx, major, minor, git_tag);
pcercuei 0:df031b60ca29 252
pcercuei 0:df031b60ca29 253 iio_library_get_version(major, minor, git_tag);
pcercuei 0:df031b60ca29 254 return 0;
pcercuei 0:df031b60ca29 255 }
pcercuei 0:df031b60ca29 256
pcercuei 0:df031b60ca29 257 int iio_context_set_timeout(struct iio_context *ctx, unsigned int timeout)
pcercuei 0:df031b60ca29 258 {
pcercuei 0:df031b60ca29 259 if (ctx->ops->set_timeout)
pcercuei 0:df031b60ca29 260 return ctx->ops->set_timeout(ctx, timeout);
pcercuei 0:df031b60ca29 261 else
pcercuei 0:df031b60ca29 262 return -ENOSYS;
pcercuei 0:df031b60ca29 263 }
pcercuei 0:df031b60ca29 264
pcercuei 0:df031b60ca29 265 struct iio_context * iio_context_clone(const struct iio_context *ctx)
pcercuei 0:df031b60ca29 266 {
pcercuei 0:df031b60ca29 267 if (ctx->ops->clone) {
pcercuei 0:df031b60ca29 268 return ctx->ops->clone(ctx);
pcercuei 0:df031b60ca29 269 } else {
pcercuei 0:df031b60ca29 270 errno = ENOSYS;
pcercuei 0:df031b60ca29 271 return NULL;
pcercuei 0:df031b60ca29 272 }
pcercuei 0:df031b60ca29 273 }
pcercuei 0:df031b60ca29 274
pcercuei 0:df031b60ca29 275 struct iio_context * iio_create_context_from_uri(const char *uri)
pcercuei 0:df031b60ca29 276 {
pcercuei 0:df031b60ca29 277 #ifdef WITH_LOCAL_BACKEND
pcercuei 0:df031b60ca29 278 if (strcmp(uri, "local:") == 0) /* No address part */
pcercuei 0:df031b60ca29 279 return iio_create_local_context();
pcercuei 0:df031b60ca29 280 #endif
pcercuei 0:df031b60ca29 281
pcercuei 0:df031b60ca29 282 #ifdef WITH_XML_BACKEND
pcercuei 0:df031b60ca29 283 if (strncmp(uri, "xml:", sizeof("xml:") - 1) == 0)
pcercuei 0:df031b60ca29 284 return iio_create_xml_context(uri + sizeof("xml:") - 1);
pcercuei 0:df031b60ca29 285 #endif
pcercuei 0:df031b60ca29 286
pcercuei 0:df031b60ca29 287 #ifdef WITH_NETWORK_BACKEND
pcercuei 0:df031b60ca29 288 if (strncmp(uri, "ip:", sizeof("ip:") - 1) == 0)
pcercuei 0:df031b60ca29 289 return iio_create_network_context(uri+3);
pcercuei 0:df031b60ca29 290 #endif
pcercuei 0:df031b60ca29 291
pcercuei 0:df031b60ca29 292 #ifdef WITH_USB_BACKEND
pcercuei 0:df031b60ca29 293 if (strncmp(uri, "usb:", sizeof("usb:") - 1) == 0)
pcercuei 0:df031b60ca29 294 return usb_create_context_from_uri(uri);
pcercuei 0:df031b60ca29 295 #endif
pcercuei 0:df031b60ca29 296
pcercuei 0:df031b60ca29 297 #ifdef WITH_SERIAL_BACKEND
pcercuei 0:df031b60ca29 298 if (strncmp(uri, "serial:", sizeof("serial:") - 1) == 0)
pcercuei 0:df031b60ca29 299 return serial_create_context_from_uri(uri);
pcercuei 0:df031b60ca29 300 #endif
pcercuei 0:df031b60ca29 301
pcercuei 0:df031b60ca29 302 errno = ENOSYS;
pcercuei 0:df031b60ca29 303 return NULL;
pcercuei 0:df031b60ca29 304 }
pcercuei 0:df031b60ca29 305
pcercuei 0:df031b60ca29 306 struct iio_context * iio_create_default_context(void)
pcercuei 0:df031b60ca29 307 {
pcercuei 0:df031b60ca29 308 char *hostname = getenv("IIOD_REMOTE");
pcercuei 0:df031b60ca29 309
pcercuei 0:df031b60ca29 310 if (hostname) {
pcercuei 0:df031b60ca29 311 struct iio_context *ctx;
pcercuei 0:df031b60ca29 312
pcercuei 0:df031b60ca29 313 ctx = iio_create_context_from_uri(hostname);
pcercuei 0:df031b60ca29 314 if (ctx)
pcercuei 0:df031b60ca29 315 return ctx;
pcercuei 0:df031b60ca29 316
pcercuei 0:df031b60ca29 317 #ifdef WITH_NETWORK_BACKEND
pcercuei 0:df031b60ca29 318 /* If the environment variable is an empty string, we will
pcercuei 0:df031b60ca29 319 * discover the server using ZeroConf */
pcercuei 0:df031b60ca29 320 if (strlen(hostname) == 0)
pcercuei 0:df031b60ca29 321 hostname = NULL;
pcercuei 0:df031b60ca29 322
pcercuei 0:df031b60ca29 323 return iio_create_network_context(hostname);
pcercuei 0:df031b60ca29 324 #endif
pcercuei 0:df031b60ca29 325 }
pcercuei 0:df031b60ca29 326
pcercuei 0:df031b60ca29 327 return iio_create_local_context();
pcercuei 0:df031b60ca29 328 }
pcercuei 0:df031b60ca29 329
pcercuei 0:df031b60ca29 330 struct iio_context * iio_create_local_context(void)
pcercuei 0:df031b60ca29 331 {
pcercuei 0:df031b60ca29 332 #ifdef WITH_LOCAL_BACKEND
pcercuei 0:df031b60ca29 333 return local_create_context();
pcercuei 0:df031b60ca29 334 #else
pcercuei 0:df031b60ca29 335 errno = ENOSYS;
pcercuei 0:df031b60ca29 336 return NULL;
pcercuei 0:df031b60ca29 337 #endif
pcercuei 0:df031b60ca29 338 }
pcercuei 0:df031b60ca29 339
pcercuei 0:df031b60ca29 340 struct iio_context * iio_create_network_context(const char *hostname)
pcercuei 0:df031b60ca29 341 {
pcercuei 0:df031b60ca29 342 #ifdef WITH_NETWORK_BACKEND
pcercuei 0:df031b60ca29 343 return network_create_context(hostname);
pcercuei 0:df031b60ca29 344 #else
pcercuei 0:df031b60ca29 345 errno = ENOSYS;
pcercuei 0:df031b60ca29 346 return NULL;
pcercuei 0:df031b60ca29 347 #endif
pcercuei 0:df031b60ca29 348 }
pcercuei 0:df031b60ca29 349
pcercuei 0:df031b60ca29 350 struct iio_context * iio_create_xml_context_mem(const char *xml, size_t len)
pcercuei 0:df031b60ca29 351 {
pcercuei 0:df031b60ca29 352 #ifdef WITH_XML_BACKEND
pcercuei 0:df031b60ca29 353 return xml_create_context_mem(xml, len);
pcercuei 0:df031b60ca29 354 #else
pcercuei 0:df031b60ca29 355 errno = ENOSYS;
pcercuei 0:df031b60ca29 356 return NULL;
pcercuei 0:df031b60ca29 357 #endif
pcercuei 0:df031b60ca29 358 }
pcercuei 0:df031b60ca29 359
pcercuei 0:df031b60ca29 360 struct iio_context * iio_create_xml_context(const char *xml_file)
pcercuei 0:df031b60ca29 361 {
pcercuei 0:df031b60ca29 362 #ifdef WITH_XML_BACKEND
pcercuei 0:df031b60ca29 363 return xml_create_context(xml_file);
pcercuei 0:df031b60ca29 364 #else
pcercuei 0:df031b60ca29 365 errno = ENOSYS;
pcercuei 0:df031b60ca29 366 return NULL;
pcercuei 0:df031b60ca29 367 #endif
pcercuei 0:df031b60ca29 368 }
pcercuei 3:d147beabba0e 369
pcercuei 3:d147beabba0e 370 unsigned int iio_context_get_attrs_count(const struct iio_context *ctx)
pcercuei 3:d147beabba0e 371 {
pcercuei 3:d147beabba0e 372 return ctx->nb_attrs;
pcercuei 3:d147beabba0e 373 }
pcercuei 3:d147beabba0e 374
pcercuei 3:d147beabba0e 375 int iio_context_get_attr(const struct iio_context *ctx, unsigned int index,
pcercuei 3:d147beabba0e 376 const char **name, const char **value)
pcercuei 3:d147beabba0e 377 {
pcercuei 3:d147beabba0e 378 if (index >= ctx->nb_attrs)
pcercuei 3:d147beabba0e 379 return -EINVAL;
pcercuei 3:d147beabba0e 380
pcercuei 3:d147beabba0e 381 if (name)
pcercuei 3:d147beabba0e 382 *name = ctx->attrs[index];
pcercuei 3:d147beabba0e 383 if (value)
pcercuei 3:d147beabba0e 384 *value = ctx->values[index];
pcercuei 3:d147beabba0e 385 return 0;
pcercuei 3:d147beabba0e 386 }
pcercuei 3:d147beabba0e 387
pcercuei 3:d147beabba0e 388 const char * iio_context_get_attr_value(
pcercuei 3:d147beabba0e 389 const struct iio_context *ctx, const char *name)
pcercuei 3:d147beabba0e 390 {
pcercuei 3:d147beabba0e 391 unsigned int i;
pcercuei 3:d147beabba0e 392
pcercuei 3:d147beabba0e 393 for (i = 0; i < ctx->nb_attrs; i++) {
pcercuei 3:d147beabba0e 394 if (!strcmp(name, ctx->attrs[i]))
pcercuei 3:d147beabba0e 395 return ctx->values[i];
pcercuei 3:d147beabba0e 396 }
pcercuei 3:d147beabba0e 397
pcercuei 3:d147beabba0e 398 return NULL;
pcercuei 3:d147beabba0e 399 }
pcercuei 3:d147beabba0e 400
pcercuei 3:d147beabba0e 401 int iio_context_add_attr(struct iio_context *ctx,
pcercuei 3:d147beabba0e 402 const char *key, const char *value)
pcercuei 3:d147beabba0e 403 {
pcercuei 3:d147beabba0e 404 char **attrs, **values, *new_key, *new_val;
pcercuei 3:d147beabba0e 405
pcercuei 3:d147beabba0e 406 attrs = realloc(ctx->attrs,
pcercuei 3:d147beabba0e 407 (ctx->nb_attrs + 1) * sizeof(*ctx->attrs));
pcercuei 3:d147beabba0e 408 if (!attrs)
pcercuei 3:d147beabba0e 409 return -ENOMEM;
pcercuei 3:d147beabba0e 410
pcercuei 3:d147beabba0e 411 ctx->attrs = attrs;
pcercuei 3:d147beabba0e 412
pcercuei 3:d147beabba0e 413 values = realloc(ctx->values,
pcercuei 3:d147beabba0e 414 (ctx->nb_attrs + 1) * sizeof(*ctx->values));
pcercuei 3:d147beabba0e 415 if (!values)
pcercuei 3:d147beabba0e 416 return -ENOMEM;
pcercuei 3:d147beabba0e 417
pcercuei 3:d147beabba0e 418 ctx->values = values;
pcercuei 3:d147beabba0e 419
pcercuei 3:d147beabba0e 420 new_key = iio_strdup(key);
pcercuei 3:d147beabba0e 421 if (!new_key)
pcercuei 3:d147beabba0e 422 return -ENOMEM;
pcercuei 3:d147beabba0e 423
pcercuei 3:d147beabba0e 424 new_val = iio_strdup(value);
pcercuei 3:d147beabba0e 425 if (!new_val) {
pcercuei 3:d147beabba0e 426 free(new_key);
pcercuei 3:d147beabba0e 427 return -ENOMEM;
pcercuei 3:d147beabba0e 428 }
pcercuei 3:d147beabba0e 429
pcercuei 3:d147beabba0e 430 ctx->attrs[ctx->nb_attrs] = new_key;
pcercuei 3:d147beabba0e 431 ctx->values[ctx->nb_attrs] = new_val;
pcercuei 3:d147beabba0e 432 ctx->nb_attrs++;
pcercuei 3:d147beabba0e 433 return 0;
pcercuei 3:d147beabba0e 434 }
pcercuei 0:df031b60ca29 435