session.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2010-2012 Bert Vermeulen <bert@biot.com>
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <unistd.h>
  23 #include <string.h>
  24 #include <glib.h>
  25 #include "libsigrok.h"
  26 #include "libsigrok-internal.h"
  27
  28 #define LOG_PREFIX "session"
  29
  30 /**
  31  * @file
  32  *
  33  * Creating, using, or destroying libsigrok sessions.
  34  */
  35
  36 /**
  37  * @defgroup grp_session Session handling
  38  *
  39  * Creating, using, or destroying libsigrok sessions.
  40  *
  41  * @{
  42  */
  43
  44 struct source {
  45         int timeout;
  46         sr_receive_data_callback_t cb;
  47         void *cb_data;
  48
  49         /* This is used to keep track of the object (fd, pollfd or channel) which is
  50          * being polled and will be used to match the source when removing it again.
  51          */
  52         gintptr poll_object;
  53 };
  54
  55 struct datafeed_callback {
  56         sr_datafeed_callback_t cb;
  57         void *cb_data;
  58 };
  59
  60 /* There can only be one session at a time. */
  61 /* 'session' is not static, it's used elsewhere (via 'extern'). */
  62 struct sr_session *session;
  63
  64 /**
  65  * Create a new session.
  66  *
  67  * @todo Should it use the file-global "session" variable or take an argument?
  68  *       The same question applies to all the other session functions.
  69  *
  70  * @retval NULL Error.
  71  * @retval other A pointer to the newly allocated session.
  72  */
  73 SR_API struct sr_session *sr_session_new(void)
  74 {
  75         if (!(session = g_try_malloc0(sizeof(struct sr_session)))) {
  76                 sr_err("Session malloc failed.");
  77                 return NULL;
  78         }
  79
  80         session->source_timeout = -1;
  81         session->running = FALSE;
  82         session->abort_session = FALSE;
  83         g_mutex_init(&session->stop_mutex);
  84
  85         return session;
  86 }
  87
  88 /**
  89  * Destroy the current session.
  90  * This frees up all memory used by the session.
  91  *
  92  * @retval SR_OK Success.
  93  * @retval SR_ERR_BUG No session exists.
  94  */
  95 SR_API int sr_session_destroy(void)
  96 {
  97         if (!session) {
  98                 sr_err("%s: session was NULL", __func__);
  99                 return SR_ERR_BUG;
 100         }
 101
 102         sr_session_dev_remove_all();
 103
 104         /* TODO: Error checks needed? */
 105
 106         g_mutex_clear(&session->stop_mutex);
 107
 108         g_free(session);
 109         session = NULL;
 110
 111         return SR_OK;
 112 }
 113
 114 /**
 115  * Remove all the devices from the current session.
 116  *
 117  * The session itself (i.e., the struct sr_session) is not free'd and still
 118  * exists after this function returns.
 119  *
 120  * @retval SR_OK Success.
 121  * @retval SR_ERR_BUG No session exists.
 122  */
 123 SR_API int sr_session_dev_remove_all(void)
 124 {
 125         if (!session) {
 126                 sr_err("%s: session was NULL", __func__);
 127                 return SR_ERR_BUG;
 128         }
 129
 130         g_slist_free(session->devs);
 131         session->devs = NULL;
 132
 133         return SR_OK;
 134 }
 135
 136 /**
 137  * Add a device instance to the current session.
 138  *
 139  * @param sdi The device instance to add to the current session. Must not
 140  *            be NULL. Also, sdi->driver and sdi->driver->dev_open must
 141  *            not be NULL.
 142  *
 143  * @retval SR_OK Success.
 144  * @retval SR_ERR_ARG Invalid argument.
 145  * @retval SR_ERR_BUG No session exists.
 146  */
 147 SR_API int sr_session_dev_add(const struct sr_dev_inst *sdi)
 148 {
 149         int ret;
 150
 151         if (!sdi) {
 152                 sr_err("%s: sdi was NULL", __func__);
 153                 return SR_ERR_ARG;
 154         }
 155
 156         if (!session) {
 157                 sr_err("%s: session was NULL", __func__);
 158                 return SR_ERR_BUG;
 159         }
 160
 161         /* If sdi->driver is NULL, this is a virtual device. */
 162         if (!sdi->driver) {
 163                 sr_dbg("%s: sdi->driver was NULL, this seems to be "
 164                        "a virtual device; continuing", __func__);
 165                 /* Just add the device, don't run dev_open(). */
 166                 session->devs = g_slist_append(session->devs, (gpointer)sdi);
 167                 return SR_OK;
 168         }
 169
 170         /* sdi->driver is non-NULL (i.e. we have a real device). */
 171         if (!sdi->driver->dev_open) {
 172                 sr_err("%s: sdi->driver->dev_open was NULL", __func__);
 173                 return SR_ERR_BUG;
 174         }
 175
 176         session->devs = g_slist_append(session->devs, (gpointer)sdi);
 177
 178         if (session->running) {
 179                 /* Adding a device to a running session. Start acquisition
 180                  * on that device now. */
 181                 if ((ret = sdi->driver->dev_acquisition_start(sdi,
 182                                                 (void *)sdi)) != SR_OK)
 183                         sr_err("Failed to start acquisition of device in "
 184                                         "running session: %d", ret);
 185         }
 186
 187         return SR_OK;
 188 }
 189
 190 /**
 191  * List all device instances attached to the current session.
 192  *
 193  * @param devlist A pointer where the device instance list will be
 194  *                stored on return. If no devices are in the session,
 195  *                this will be NULL. Each element in the list points
 196  *                to a struct sr_dev_inst *.
 197  *                The list must be freed by the caller, but not the
 198  *                elements pointed to.
 199  *
 200  * @retval SR_OK Success.
 201  * @retval SR_ERR Invalid argument.
 202  */
 203 SR_API int sr_session_dev_list(GSList **devlist)
 204 {
 205
 206         *devlist = NULL;
 207
 208         if (!session)
 209                 return SR_ERR;
 210
 211         *devlist = g_slist_copy(session->devs);
 212
 213         return SR_OK;
 214 }
 215
 216 /**
 217  * Remove all datafeed callbacks in the current session.
 218  *
 219  * @retval SR_OK Success.
 220  * @retval SR_ERR_BUG No session exists.
 221  */
 222 SR_API int sr_session_datafeed_callback_remove_all(void)
 223 {
 224         if (!session) {
 225                 sr_err("%s: session was NULL", __func__);
 226                 return SR_ERR_BUG;
 227         }
 228
 229         g_slist_free_full(session->datafeed_callbacks, g_free);
 230         session->datafeed_callbacks = NULL;
 231
 232         return SR_OK;
 233 }
 234
 235 /**
 236  * Add a datafeed callback to the current session.
 237  *
 238  * @param cb Function to call when a chunk of data is received.
 239  *           Must not be NULL.
 240  * @param cb_data Opaque pointer passed in by the caller.
 241  *
 242  * @retval SR_OK Success.
 243  * @retval SR_ERR_BUG No session exists.
 244  */
 245 SR_API int sr_session_datafeed_callback_add(sr_datafeed_callback_t cb, void *cb_data)
 246 {
 247         struct datafeed_callback *cb_struct;
 248
 249         if (!session) {
 250                 sr_err("%s: session was NULL", __func__);
 251                 return SR_ERR_BUG;
 252         }
 253
 254         if (!cb) {
 255                 sr_err("%s: cb was NULL", __func__);
 256                 return SR_ERR_ARG;
 257         }
 258
 259         if (!(cb_struct = g_try_malloc0(sizeof(struct datafeed_callback))))
 260                 return SR_ERR_MALLOC;
 261
 262         cb_struct->cb = cb;
 263         cb_struct->cb_data = cb_data;
 264
 265         session->datafeed_callbacks =
 266             g_slist_append(session->datafeed_callbacks, cb_struct);
 267
 268         return SR_OK;
 269 }
 270
 271 /**
 272  * Call every device in the session's callback.
 273  *
 274  * For sessions not driven by select loops such as sr_session_run(),
 275  * but driven by another scheduler, this can be used to poll the devices
 276  * from within that scheduler.
 277  *
 278  * @param block If TRUE, this call will wait for any of the session's
 279  *              sources to fire an event on the file descriptors, or
 280  *              any of their timeouts to activate. In other words, this
 281  *              can be used as a select loop.
 282  *              If FALSE, all sources have their callback run, regardless
 283  *              of file descriptor or timeout status.
 284  *
 285  * @retval SR_OK Success.
 286  * @retval SR_ERR Error occured.
 287  */
 288 static int sr_session_iteration(gboolean block)
 289 {
 290         unsigned int i;
 291         int ret;
 292
 293         ret = g_poll(session->pollfds, session->num_sources,
 294                         block ? session->source_timeout : 0);
 295         for (i = 0; i < session->num_sources; i++) {
 296                 if (session->pollfds[i].revents > 0 || (ret == 0
 297                         && session->source_timeout == session->sources[i].timeout)) {
 298                         /*
 299                          * Invoke the source's callback on an event,
 300                          * or if the poll timed out and this source
 301                          * asked for that timeout.
 302                          */
 303                         if (!session->sources[i].cb(session->pollfds[i].fd,
 304                                         session->pollfds[i].revents,
 305                                         session->sources[i].cb_data))
 306                                 sr_session_source_remove(session->sources[i].poll_object);
 307                 }
 308                 /*
 309                  * We want to take as little time as possible to stop
 310                  * the session if we have been told to do so. Therefore,
 311                  * we check the flag after processing every source, not
 312                  * just once per main event loop.
 313                  */
 314                 g_mutex_lock(&session->stop_mutex);
 315                 if (session->abort_session) {
 316                         sr_session_stop_sync();
 317                         /* But once is enough. */
 318                         session->abort_session = FALSE;
 319                 }
 320                 g_mutex_unlock(&session->stop_mutex);
 321         }
 322
 323         return SR_OK;
 324 }
 325
 326 /**
 327  * Start a session.
 328  *
 329  * There can only be one session at a time.
 330  *
 331  * @retval SR_OK Success.
 332  * @retval SR_ERR Error occured.
 333  */
 334 SR_API int sr_session_start(void)
 335 {
 336         struct sr_dev_inst *sdi;
 337         GSList *l;
 338         int ret;
 339
 340         if (!session) {
 341                 sr_err("%s: session was NULL; a session must be "
 342                        "created before starting it.", __func__);
 343                 return SR_ERR_BUG;
 344         }
 345
 346         if (!session->devs) {
 347                 sr_err("%s: session->devs was NULL; a session "
 348                        "cannot be started without devices.", __func__);
 349                 return SR_ERR_BUG;
 350         }
 351
 352         sr_info("Starting.");
 353
 354         ret = SR_OK;
 355         for (l = session->devs; l; l = l->next) {
 356                 sdi = l->data;
 357                 if ((ret = sdi->driver->dev_acquisition_start(sdi, sdi)) != SR_OK) {
 358                         sr_err("%s: could not start an acquisition "
 359                                "(%s)", __func__, sr_strerror(ret));
 360                         break;
 361                 }
 362         }
 363
 364         /* TODO: What if there are multiple devices? Which return code? */
 365
 366         return ret;
 367 }
 368
 369 /**
 370  * Run the session.
 371  *
 372  * @retval SR_OK Success.
 373  * @retval SR_ERR_BUG Error occured.
 374  */
 375 SR_API int sr_session_run(void)
 376 {
 377         if (!session) {
 378                 sr_err("%s: session was NULL; a session must be "
 379                        "created first, before running it.", __func__);
 380                 return SR_ERR_BUG;
 381         }
 382
 383         if (!session->devs) {
 384                 /* TODO: Actually the case? */
 385                 sr_err("%s: session->devs was NULL; a session "
 386                        "cannot be run without devices.", __func__);
 387                 return SR_ERR_BUG;
 388         }
 389         session->running = TRUE;
 390
 391         sr_info("Running.");
 392
 393         /* Do we have real sources? */
 394         if (session->num_sources == 1 && session->pollfds[0].fd == -1) {
 395                 /* Dummy source, freewheel over it. */
 396                 while (session->num_sources)
 397                         session->sources[0].cb(-1, 0, session->sources[0].cb_data);
 398         } else {
 399                 /* Real sources, use g_poll() main loop. */
 400                 while (session->num_sources)
 401                         sr_session_iteration(TRUE);
 402         }
 403
 404         return SR_OK;
 405 }
 406
 407 /**
 408  * Stop the current session.
 409  *
 410  * The current session is stopped immediately, with all acquisition sessions
 411  * being stopped and hardware drivers cleaned up.
 412  *
 413  * This must be called from within the session thread, to prevent freeing
 414  * resources that the session thread will try to use.
 415  *
 416  * @retval SR_OK Success.
 417  * @retval SR_ERR_BUG No session exists.
 418  *
 419  * @private
 420  */
 421 SR_PRIV int sr_session_stop_sync(void)
 422 {
 423         struct sr_dev_inst *sdi;
 424         GSList *l;
 425
 426         if (!session) {
 427                 sr_err("%s: session was NULL", __func__);
 428                 return SR_ERR_BUG;
 429         }
 430
 431         sr_info("Stopping.");
 432
 433         for (l = session->devs; l; l = l->next) {
 434                 sdi = l->data;
 435                 if (sdi->driver) {
 436                         if (sdi->driver->dev_acquisition_stop)
 437                                 sdi->driver->dev_acquisition_stop(sdi, sdi);
 438                 }
 439         }
 440         session->running = FALSE;
 441
 442         return SR_OK;
 443 }
 444
 445 /**
 446  * Stop the current session.
 447  *
 448  * The current session is stopped immediately, with all acquisition sessions
 449  * being stopped and hardware drivers cleaned up.
 450  *
 451  * If the session is run in a separate thread, this function will not block
 452  * until the session is finished executing. It is the caller's responsibility
 453  * to wait for the session thread to return before assuming that the session is
 454  * completely decommissioned.
 455  *
 456  * @retval SR_OK Success.
 457  * @retval SR_ERR_BUG No session exists.
 458  */
 459 SR_API int sr_session_stop(void)
 460 {
 461         if (!session) {
 462                 sr_err("%s: session was NULL", __func__);
 463                 return SR_ERR_BUG;
 464         }
 465
 466         g_mutex_lock(&session->stop_mutex);
 467         session->abort_session = TRUE;
 468         g_mutex_unlock(&session->stop_mutex);
 469
 470         return SR_OK;
 471 }
 472
 473 /**
 474  * Debug helper.
 475  *
 476  * @param packet The packet to show debugging information for.
 477  */
 478 static void datafeed_dump(const struct sr_datafeed_packet *packet)
 479 {
 480         const struct sr_datafeed_logic *logic;
 481         const struct sr_datafeed_analog *analog;
 482
 483         switch (packet->type) {
 484         case SR_DF_HEADER:
 485                 sr_dbg("bus: Received SR_DF_HEADER packet.");
 486                 break;
 487         case SR_DF_TRIGGER:
 488                 sr_dbg("bus: Received SR_DF_TRIGGER packet.");
 489                 break;
 490         case SR_DF_META:
 491                 sr_dbg("bus: Received SR_DF_META packet.");
 492                 break;
 493         case SR_DF_LOGIC:
 494                 logic = packet->payload;
 495                 sr_dbg("bus: Received SR_DF_LOGIC packet (%" PRIu64 " bytes).",
 496                        logic->length);
 497                 break;
 498         case SR_DF_ANALOG:
 499                 analog = packet->payload;
 500                 sr_dbg("bus: Received SR_DF_ANALOG packet (%d samples).",
 501                        analog->num_samples);
 502                 break;
 503         case SR_DF_END:
 504                 sr_dbg("bus: Received SR_DF_END packet.");
 505                 break;
 506         case SR_DF_FRAME_BEGIN:
 507                 sr_dbg("bus: Received SR_DF_FRAME_BEGIN packet.");
 508                 break;
 509         case SR_DF_FRAME_END:
 510                 sr_dbg("bus: Received SR_DF_FRAME_END packet.");
 511                 break;
 512         default:
 513                 sr_dbg("bus: Received unknown packet type: %d.", packet->type);
 514                 break;
 515         }
 516 }
 517
 518 /**
 519  * Send a packet to whatever is listening on the datafeed bus.
 520  *
 521  * Hardware drivers use this to send a data packet to the frontend.
 522  *
 523  * @param sdi TODO.
 524  * @param packet The datafeed packet to send to the session bus.
 525  *
 526  * @retval SR_OK Success.
 527  * @retval SR_ERR_ARG Invalid argument.
 528  *
 529  * @private
 530  */
 531 SR_PRIV int sr_session_send(const struct sr_dev_inst *sdi,
 532                             const struct sr_datafeed_packet *packet)
 533 {
 534         GSList *l;
 535         struct datafeed_callback *cb_struct;
 536
 537         if (!sdi) {
 538                 sr_err("%s: sdi was NULL", __func__);
 539                 return SR_ERR_ARG;
 540         }
 541
 542         if (!packet) {
 543                 sr_err("%s: packet was NULL", __func__);
 544                 return SR_ERR_ARG;
 545         }
 546
 547         for (l = session->datafeed_callbacks; l; l = l->next) {
 548                 if (sr_log_loglevel_get() >= SR_LOG_DBG)
 549                         datafeed_dump(packet);
 550                 cb_struct = l->data;
 551                 cb_struct->cb(sdi, packet, cb_struct->cb_data);
 552         }
 553
 554         return SR_OK;
 555 }
 556
 557 /**
 558  * Add an event source for a file descriptor.
 559  *
 560  * @param pollfd The GPollFD.
 561  * @param[in] timeout Max time to wait before the callback is called,
 562  *              ignored if 0.
 563  * @param cb Callback function to add. Must not be NULL.
 564  * @param cb_data Data for the callback function. Can be NULL.
 565  * @param poll_object TODO.
 566  *
 567  * @retval SR_OK Success.
 568  * @retval SR_ERR_ARG Invalid argument.
 569  * @retval SR_ERR_MALLOC Memory allocation error.
 570  */
 571 static int _sr_session_source_add(GPollFD *pollfd, int timeout,
 572         sr_receive_data_callback_t cb, void *cb_data, gintptr poll_object)
 573 {
 574         struct source *new_sources, *s;
 575         GPollFD *new_pollfds;
 576
 577         if (!cb) {
 578                 sr_err("%s: cb was NULL", __func__);
 579                 return SR_ERR_ARG;
 580         }
 581
 582         /* Note: cb_data can be NULL, that's not a bug. */
 583
 584         new_pollfds = g_try_realloc(session->pollfds,
 585                         sizeof(GPollFD) * (session->num_sources + 1));
 586         if (!new_pollfds) {
 587                 sr_err("%s: new_pollfds malloc failed", __func__);
 588                 return SR_ERR_MALLOC;
 589         }
 590
 591         new_sources = g_try_realloc(session->sources, sizeof(struct source) *
 592                         (session->num_sources + 1));
 593         if (!new_sources) {
 594                 sr_err("%s: new_sources malloc failed", __func__);
 595                 return SR_ERR_MALLOC;
 596         }
 597
 598         new_pollfds[session->num_sources] = *pollfd;
 599         s = &new_sources[session->num_sources++];
 600         s->timeout = timeout;
 601         s->cb = cb;
 602         s->cb_data = cb_data;
 603         s->poll_object = poll_object;
 604         session->pollfds = new_pollfds;
 605         session->sources = new_sources;
 606
 607         if (timeout != session->source_timeout && timeout > 0
 608             && (session->source_timeout == -1 || timeout < session->source_timeout))
 609                 session->source_timeout = timeout;
 610
 611         return SR_OK;
 612 }
 613
 614 /**
 615  * Add an event source for a file descriptor.
 616  *
 617  * @param fd The file descriptor.
 618  * @param events Events to check for.
 619  * @param timeout Max time to wait before the callback is called, ignored if 0.
 620  * @param cb Callback function to add. Must not be NULL.
 621  * @param cb_data Data for the callback function. Can be NULL.
 622  *
 623  * @retval SR_OK Success.
 624  * @retval SR_ERR_ARG Invalid argument.
 625  * @retval SR_ERR_MALLOC Memory allocation error.
 626  */
 627 SR_API int sr_session_source_add(int fd, int events, int timeout,
 628                 sr_receive_data_callback_t cb, void *cb_data)
 629 {
 630         GPollFD p;
 631
 632         p.fd = fd;
 633         p.events = events;
 634
 635         return _sr_session_source_add(&p, timeout, cb, cb_data, (gintptr)fd);
 636 }
 637
 638 /**
 639  * Add an event source for a GPollFD.
 640  *
 641  * @param pollfd The GPollFD.
 642  * @param timeout Max time to wait before the callback is called, ignored if 0.
 643  * @param cb Callback function to add. Must not be NULL.
 644  * @param cb_data Data for the callback function. Can be NULL.
 645  *
 646  * @retval SR_OK Success.
 647  * @retval SR_ERR_ARG Invalid argument.
 648  * @retval SR_ERR_MALLOC Memory allocation error.
 649  */
 650 SR_API int sr_session_source_add_pollfd(GPollFD *pollfd, int timeout,
 651                 sr_receive_data_callback_t cb, void *cb_data)
 652 {
 653         return _sr_session_source_add(pollfd, timeout, cb,
 654                                       cb_data, (gintptr)pollfd);
 655 }
 656
 657 /**
 658  * Add an event source for a GIOChannel.
 659  *
 660  * @param channel The GIOChannel.
 661  * @param events Events to poll on.
 662  * @param timeout Max time to wait before the callback is called, ignored if 0.
 663  * @param cb Callback function to add. Must not be NULL.
 664  * @param cb_data Data for the callback function. Can be NULL.
 665  *
 666  * @retval SR_OK Success.
 667  * @retval SR_ERR_ARG Invalid argument.
 668  * @retval SR_ERR_MALLOC Memory allocation error.
 669  */
 670 SR_API int sr_session_source_add_channel(GIOChannel *channel, int events,
 671                 int timeout, sr_receive_data_callback_t cb, void *cb_data)
 672 {
 673         GPollFD p;
 674
 675 #ifdef _WIN32
 676         g_io_channel_win32_make_pollfd(channel, events, &p);
 677 #else
 678         p.fd = g_io_channel_unix_get_fd(channel);
 679         p.events = events;
 680 #endif
 681
 682         return _sr_session_source_add(&p, timeout, cb, cb_data, (gintptr)channel);
 683 }
 684
 685 /**
 686  * Remove the source belonging to the specified channel.
 687  *
 688  * @todo Add more error checks and logging.
 689  *
 690  * @param poll_object The channel for which the source should be removed.
 691  *
 692  * @retval SR_OK Success
 693  * @retval SR_ERR_ARG Invalid arguments
 694  * @retval SR_ERR_MALLOC Memory allocation error
 695  * @retval SR_ERR_BUG Internal error
 696  */
 697 static int _sr_session_source_remove(gintptr poll_object)
 698 {
 699         struct source *new_sources;
 700         GPollFD *new_pollfds;
 701         unsigned int old;
 702
 703         if (!session->sources || !session->num_sources) {
 704                 sr_err("%s: sources was NULL", __func__);
 705                 return SR_ERR_BUG;
 706         }
 707
 708         for (old = 0; old < session->num_sources; old++) {
 709                 if (session->sources[old].poll_object == poll_object)
 710                         break;
 711         }
 712
 713         /* fd not found, nothing to do */
 714         if (old == session->num_sources)
 715                 return SR_OK;
 716
 717         session->num_sources -= 1;
 718
 719         if (old != session->num_sources) {
 720                 memmove(&session->pollfds[old], &session->pollfds[old+1],
 721                         (session->num_sources - old) * sizeof(GPollFD));
 722                 memmove(&session->sources[old], &session->sources[old+1],
 723                         (session->num_sources - old) * sizeof(struct source));
 724         }
 725
 726         new_pollfds = g_try_realloc(session->pollfds, sizeof(GPollFD) * session->num_sources);
 727         if (!new_pollfds && session->num_sources > 0) {
 728                 sr_err("%s: new_pollfds malloc failed", __func__);
 729                 return SR_ERR_MALLOC;
 730         }
 731
 732         new_sources = g_try_realloc(session->sources, sizeof(struct source) * session->num_sources);
 733         if (!new_sources && session->num_sources > 0) {
 734                 sr_err("%s: new_sources malloc failed", __func__);
 735                 return SR_ERR_MALLOC;
 736         }
 737
 738         session->pollfds = new_pollfds;
 739         session->sources = new_sources;
 740
 741         return SR_OK;
 742 }
 743
 744 /**
 745  * Remove the source belonging to the specified file descriptor.
 746  *
 747  * @param fd The file descriptor for which the source should be removed.
 748  *
 749  * @retval SR_OK Success
 750  * @retval SR_ERR_ARG Invalid argument
 751  * @retval SR_ERR_MALLOC Memory allocation error.
 752  * @retval SR_ERR_BUG Internal error.
 753  */
 754 SR_API int sr_session_source_remove(int fd)
 755 {
 756         return _sr_session_source_remove((gintptr)fd);
 757 }
 758
 759 /**
 760  * Remove the source belonging to the specified poll descriptor.
 761  *
 762  * @param pollfd The poll descriptor for which the source should be removed.
 763  *
 764  * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
 765  *         SR_ERR_MALLOC upon memory allocation errors, SR_ERR_BUG upon
 766  *         internal errors.
 767  */
 768 SR_API int sr_session_source_remove_pollfd(GPollFD *pollfd)
 769 {
 770         return _sr_session_source_remove((gintptr)pollfd);
 771 }
 772
 773 /**
 774  * Remove the source belonging to the specified channel.
 775  *
 776  * @param channel The channel for which the source should be removed.
 777  *
 778  * @retval SR_OK Success.
 779  * @retval SR_ERR_ARG Invalid argument.
 780  * @retval SR_ERR_MALLOC Memory allocation error.
 781  * @return SR_ERR_BUG Internal error.
 782  */
 783 SR_API int sr_session_source_remove_channel(GIOChannel *channel)
 784 {
 785         return _sr_session_source_remove((gintptr)channel);
 786 }
 787
 788 /** @} */