Annotation of gpl/axl/src/axl_stream.c, revision 1.1
1.1 ! misho 1: /*
! 2: * LibAxl: Another XML library
! 3: * Copyright (C) 2006 Advanced Software Production Line, S.L.
! 4: *
! 5: * This program is free software; you can redistribute it and/or
! 6: * modify it under the terms of the GNU Lesser General Public License
! 7: * as published by the Free Software Foundation; either version 2.1 of
! 8: * the License, or (at your option) any later version.
! 9: *
! 10: * This program is distributed in the hope that it will be useful,
! 11: * but WITHOUT ANY WARRANTY; without even the implied warranty of
! 12: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! 13: * GNU Lesser General Public License for more details.
! 14: *
! 15: * You should have received a copy of the GNU Lesser General Public
! 16: * License along with this program; if not, write to the Free
! 17: * Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
! 18: * 02111-1307 USA
! 19: *
! 20: * You may find a copy of the license under this software is released
! 21: * at COPYING file. This is LGPL software: you are welcome to
! 22: * develop proprietary applications using this library without any
! 23: * royalty or fee but returning back any change, improvement or
! 24: * addition in the form of source code, project image, documentation
! 25: * patches, etc.
! 26: *
! 27: * For commercial support on build XML enabled solutions contact us:
! 28: *
! 29: * Postal address:
! 30: * Advanced Software Production Line, S.L.
! 31: * Edificio Alius A, Oficina 102,
! 32: * C/ Antonio Suarez Nº 10,
! 33: * Alcalá de Henares 28802 Madrid
! 34: * Spain
! 35: *
! 36: * Email address:
! 37: * info@aspl.es - http://www.aspl.es/xml
! 38: */
! 39:
! 40: #include <axl.h>
! 41: #include <math.h>
! 42:
! 43: #define LOG_DOMAIN "axl-stream"
! 44:
! 45: /**
! 46: * @internal
! 47: *
! 48: * @brief Basic checking which allows to test if the provided size
! 49: * could be satisfied by the current status of the provided stream.
! 50: *
! 51: * @param stream The stream where the operation will be performed.
! 52: *
! 53: * @param size The size to check.
! 54: *
! 55: * @return 1 if the size falls out side the stream limit or 0 it not.
! 56: */
! 57: #define fall_out_side_checking(stream, size) ((size + stream->stream_index) > stream->stream_size)
! 58:
! 59: /**
! 60: * @internal
! 61: *
! 62: * This is the size of the buffer allocated while using the axlStream
! 63: * as a representation of a streaming media, like a file
! 64: * descriptor. This value should contain a value using the (4k * n + 1).
! 65: *
! 66: * @param stream
! 67: */
! 68: #define STREAM_BUFFER_SIZE 8192
! 69:
! 70: /**
! 71: * @internal
! 72: *
! 73: * Internal definition used to represent the maximum value used for
! 74: * calls done to match a set of chunks.
! 75: */
! 76: #define MAX_INSPECTED_CHUNKS 30
! 77:
! 78: typedef enum {
! 79: STREAM_FD,
! 80: STREAM_MEM
! 81: }axlStreamType;
! 82:
! 83: struct _axlStream {
! 84:
! 85: /* current stream content */
! 86: char * stream;
! 87:
! 88: /* where the current stream is positioned. */
! 89: int stream_index;
! 90:
! 91: /* global index for the device being streamed */
! 92: int global_index;
! 93:
! 94: /* current stream size */
! 95: int stream_size;
! 96:
! 97: /* stream buffer size (maximum amount of bytes to hold, used
! 98: * also to measure the temporal buffer) */
! 99: int buffer_size;
! 100:
! 101: /* previous inspected stream size */
! 102: int previous_inspect;
! 103:
! 104: /* last chunk get from the stream */
! 105: char * last_chunk;
! 106:
! 107: /* last near to reference. */
! 108: char * last_near_to;
! 109:
! 110: /* last get following reference */
! 111: char * last_get_following;
! 112:
! 113: /* support variable for chunk matching */
! 114: char ** chunks;
! 115:
! 116: /* support variable for chunk matching */
! 117: int * lengths;
! 118:
! 119: /* a reference to the associated element to this stream */
! 120: axlList * elements_linked;
! 121:
! 122: /*The function to execute when the element must be destroyed. */
! 123: axlDestroyFunc element_destroy;
! 124:
! 125: /* Stream type configuration. Information source is coming
! 126: * from a file descriptor of a memory address. */
! 127: axlStreamType type;
! 128:
! 129: /* File descriptor associated with the given stream. In the
! 130: * case the stream if a STREAM_FD, this is the file descriptor
! 131: * associated. */
! 132: int fd;
! 133:
! 134: /* Temporal buffer used by the stream to handle prebuffering
! 135: * operations.
! 136: */
! 137: char * temp;
! 138: char * decode_temp;
! 139: int decode_temp_size;
! 140: int decode_temp_index;
! 141: int decode_temp_last;
! 142: int decode_temp_remain;
! 143: char * source_encoding;
! 144:
! 145: /* here is how these variables are used to decode content:
! 146: *
! 147: * [ <--- decode_temp buffer ---> ] <- decode_temp_size: total buffer size (bytes)
! 148: * ^ ^
! 149: * | |
! 150: * | +-- decode_temp_last: last valid content in the buffer (bytes)
! 151: * +-- decode_temp_index: next content to be consumed (bytes)
! 152: *
! 153: * [decode_temp_remain]: is the amount of content pending to
! 154: * be decoded. That is, starting from decode_temp_remain until
! 155: * last is the valid content still to be decoded.
! 156: *
! 157: * [source_encoding]: is defined to hold the value of the
! 158: * format for the source.
! 159: */
! 160:
! 161: /* more variables used to perform work: at get until */
! 162: char * valid_chars;
! 163: int chunk_matched;
! 164: axl_bool accept_terminator;
! 165: int result_size;
! 166: int chunk_num;
! 167:
! 168: /**
! 169: * @internal Internal variable used to notify get_until
! 170: * function that the last 0 character for stream memory
! 171: * operation done in a STREAM_MEM must be considered as a
! 172: * terminator character found.
! 173: */
! 174: axl_bool zero;
! 175:
! 176: /**
! 177: * @internal Alloc function to be used to require memory for
! 178: * chunks to be returned. This is used by Axl Stream to allow
! 179: * external modules to handle how memory is allocated while
! 180: * calling to axl_stream_get_until* API.
! 181: *
! 182: * Currently, it is used by the axl_doc module to allocate axl
! 183: * stream using a string factory.
! 184: */
! 185: axlStreamAlloc alloc;
! 186:
! 187: /**
! 188: * @internal User defined data to be passed to the alloc
! 189: * function.
! 190: */
! 191: axlPointer alloc_data;
! 192:
! 193: /**
! 194: * @internal Function used by the stream to decode content
! 195: * into utf-8. This is not used in all cases.
! 196: */
! 197: axlStreamDecode decode_f;
! 198:
! 199: /**
! 200: * @internal Reference to user defined pointer provided to the
! 201: * decode_f function.
! 202: */
! 203: axlPointer decode_f_data;
! 204:
! 205: /**
! 206: * @internal Value that allows to signal that the buffer needs
! 207: * to be expanded (no matter what shows current indexes).
! 208: */
! 209: axl_bool needs_expansion;
! 210:
! 211: /**
! 212: * @internal Reference to the content check function
! 213: * installed.
! 214: */
! 215: axlStreamContentCheck check_f;
! 216:
! 217: /**
! 218: * @internal Reference to user defined pointer to be passed to
! 219: * the content check function (check_f).
! 220: */
! 221: axlPointer check_f_data;
! 222: };
! 223:
! 224:
! 225: /**
! 226: * \defgroup axl_stream_module Axl Stream Document: Abstract stream where a xml document is expected (also provided string functions)
! 227: */
! 228:
! 229: /**
! 230: * \addtogroup axl_stream_module
! 231: * @{
! 232: */
! 233:
! 234: /**
! 235: * @internal
! 236: *
! 237: * @brief Read the next available information on the file descriptor
! 238: * placing that information into the stream.
! 239: *
! 240: * @param stream The stream where the pre-buffering operation will be
! 241: * performed.
! 242: *
! 243: * @param appended_content New content to be included at the begining
! 244: * of the stream while doing the prebuffer operation. This value could
! 245: * be null.
! 246: *
! 247: * @param appended_size The size for the appended content to be added.
! 248: *
! 249: * @return \ref axl_true if the requested padding and buffer size were
! 250: * filled or \ref axl_false if end of file was reached. In that case the
! 251: * stream size is not updated.
! 252: */
! 253: axl_bool axl_stream_prebuffer (axlStream * stream)
! 254: {
! 255: int bytes_read;
! 256: int op_result;
! 257:
! 258: /* check some environment conditions */
! 259: axl_return_val_if_fail (stream, axl_false);
! 260:
! 261: /* no prebuffering is the stream type is not a file descriptor
! 262: * source and if the socket is closed */
! 263: if (stream->type != STREAM_FD || stream->fd == -1) {
! 264: return axl_false;
! 265: } /* end if */
! 266:
! 267: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "prebuffering the stream..");
! 268:
! 269: /* displace memory only if there were data already consumed */
! 270: if (stream->stream_index > 0 && ((stream->stream_size - stream->stream_index) > 0)) {
! 271:
! 272: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, " moving previous content at the begining of the buffer, current index: %d, size: %d, current status: %s",
! 273: stream->stream_index, stream->stream_size - stream->stream_index,
! 274: stream->stream + stream->stream_index);
! 275:
! 276: /* displace memory already read to be at the begining
! 277: * of the stream */
! 278: memcpy (stream->temp, stream->stream + stream->stream_index,
! 279: stream->stream_size - stream->stream_index);
! 280:
! 281: /* now copy displaced content back to the stream */
! 282: memcpy (stream->stream, stream->temp,
! 283: stream->stream_size - stream->stream_index);
! 284:
! 285: /* update the index to the positioned at the next byte
! 286: * available on the buffer */
! 287: stream->stream_size = (stream->stream_size - stream->stream_index);
! 288: } else {
! 289: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, " nothing to prebuffer on the head (stream->size=%d, stream-index=%d, buffer-size=%d)",
! 290: stream->stream_size, stream->stream_index, stream->buffer_size);
! 291:
! 292: /* check here if the buffer is full of content and a call to
! 293: * prebuffer was done */
! 294: if (((stream->stream_size == stream->buffer_size) &&
! 295: (stream->stream_index == 0)) || stream->needs_expansion) {
! 296: /* looks like the caller is prebuffering
! 297: * having all buffers full of content .. */
! 298:
! 299:
! 300: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG,
! 301: " requested to prebuffer with buffers full of content (stream-index=%d, stream-size=%d, stream-buffer-size=%d, stream-needs-expansion=%d)",
! 302: stream->stream_index, stream->stream_size, stream->buffer_size, stream->needs_expansion);
! 303:
! 304: /* unflag expansion requested */
! 305: if (stream->needs_expansion)
! 306: stream->needs_expansion = axl_false;
! 307:
! 308: /* duplicate the buffer size */
! 309: stream->buffer_size += (stream->buffer_size);
! 310: stream->stream = realloc (stream->stream, stream->buffer_size + 1);
! 311: stream->temp = realloc (stream->temp, stream->buffer_size + 1);
! 312:
! 313: if (stream->stream == NULL) {
! 314: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG,
! 315: " failed to update buffer sizes (realloc operation failed)",
! 316: stream->stream_index, stream->stream_size, stream->buffer_size);
! 317: close (stream->fd);
! 318: stream->fd = -1;
! 319: return axl_false;
! 320: } /* end if */
! 321:
! 322: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG,
! 323: " buffer updated (stream-index=%d, stream-size=%d, stream-buffer-size=%d)",
! 324: stream->stream_index, stream->stream_size, stream->buffer_size);
! 325: } else {
! 326: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG,
! 327: " clearing stream-size=%d, having stream-index=%d and stream-buffer-size=%d",
! 328: stream->stream_size, stream->stream_index, stream->buffer_size);
! 329:
! 330: /* reset if the stream size is just the content consumed */
! 331: if (stream->stream_size == stream->stream_index)
! 332: stream->stream_size = 0;
! 333: }
! 334: }
! 335:
! 336: /* reset current index */
! 337: stream->stream_index = 0;
! 338:
! 339: /* check if we have decode functions defined */
! 340: if (stream->decode_f) {
! 341: while (1) {
! 342: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG,
! 343: "check temporal decode buffer for pending content: decode_temp_index=%d, decode_temp_last=%d, decode_temp_size=%d",
! 344: stream->decode_temp_index,
! 345: stream->decode_temp_last,
! 346: stream->decode_temp_size);
! 347:
! 348: if (stream->decode_temp_last > 0) {
! 349: /* call to decode */
! 350: if (! axl_stream_decode (stream,
! 351: /* output */
! 352: stream->stream + stream->stream_size,
! 353: /* max output size */
! 354: stream->buffer_size - stream->stream_size,
! 355: /* output decoded */
! 356: &bytes_read, &op_result, NULL)) {
! 357: __axl_log (LOG_DOMAIN, AXL_LEVEL_CRITICAL, "failed to decode content at the temporal decode buffer");
! 358: return axl_false;
! 359: } /* end if */
! 360:
! 361: /* check if the decode operation
! 362: * signaled that not enough espace was
! 363: * available to decode and no output
! 364: * was decoed, int his case flag the
! 365: * stream to do a stream expansion on
! 366: * the next call */
! 367: if (op_result == 2 && bytes_read == 0)
! 368: stream->needs_expansion = axl_true;
! 369:
! 370: /* add bytes read to the size */
! 371: stream->stream_size += bytes_read;
! 372:
! 373: } /* end if */
! 374:
! 375: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG,
! 376: "after checking to decode, op_result=%d, bytes_read=%d, stream->buffer_size=%d, stream->stream_size=%d",
! 377: op_result, bytes_read, stream->buffer_size, stream->stream_size);
! 378:
! 379: /* stop if no enought space if left and no
! 380: * more bytes were translated */
! 381: if (op_result == 2)
! 382: break;
! 383:
! 384: /* check if there are still space to decode at the stream */
! 385: if ((stream->buffer_size - stream->stream_size) > 0) {
! 386: /* read content inside the decde temp buffer */
! 387: bytes_read = read (stream->fd, stream->decode_temp + stream->decode_temp_last,
! 388: stream->decode_temp_size - stream->decode_temp_last);
! 389:
! 390: /* update the amount of data available tat the decode temp */
! 391: if (bytes_read > 0)
! 392: stream->decode_temp_last += bytes_read;
! 393: else if (bytes_read == 0 && stream->fd > 0) {
! 394: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "end of file reached");
! 395: close (stream->fd);
! 396: stream->fd = -1;
! 397: } /* end if */
! 398: } else {
! 399: /* no more space is available at the reading buffer */
! 400: break;
! 401: } /* end if */
! 402:
! 403: /* check to terminate */
! 404: if (stream->decode_temp_index == 0 &&
! 405: stream->decode_temp_last == 0 &&
! 406: stream->fd == -1)
! 407: return axl_true;
! 408:
! 409: } /* end while */
! 410:
! 411: } else {
! 412:
! 413: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, " reading on buffer index: %d, size: %d (starting from: %d, length: %d)",
! 414: stream->stream_index, stream->stream_size, stream->stream_size, stream->buffer_size - stream->stream_size);
! 415:
! 416: /* read current content */
! 417: bytes_read = read (stream->fd, stream->stream + stream->stream_size,
! 418: stream->buffer_size - stream->stream_size);
! 419:
! 420:
! 421: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, " bytes read from the file, size %d", bytes_read);
! 422:
! 423: /* call to check */
! 424: if (stream->check_f) {
! 425: /* call to check */
! 426: if (! axl_stream_content_check (stream, stream->stream + stream->stream_size, bytes_read, NULL)) {
! 427: __axl_log (LOG_DOMAIN, AXL_LEVEL_CRITICAL, "failed to prebuffer, content check function have failed");
! 428: return axl_false;
! 429: }
! 430: } /* end if */
! 431:
! 432: /* check for end of file reached */
! 433: if (bytes_read == 0) {
! 434: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "end of file reached");
! 435: close (stream->fd);
! 436: stream->fd = -1;
! 437: return axl_false;
! 438: }
! 439:
! 440: /* set the new size, that is the padding, the content already
! 441: * read, and the bytes already read */
! 442: stream->stream_size += bytes_read;
! 443: } /* end if */
! 444:
! 445: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, " (before read) current buffer size: %d",
! 446: stream->stream_size);
! 447:
! 448: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, " prebuffered data: stream size: %d, new content: %s",
! 449: bytes_read, stream->stream + stream->stream_index);
! 450:
! 451: return axl_true;
! 452: }
! 453:
! 454: /**
! 455: * @brief Creates a new byte stream using as data the string pointer
! 456: * and the size.
! 457: *
! 458: * The \ref axlStream object is an abstraction that allows to
! 459: * interface with a memory chunk, a file descriptor (or a socket) or a
! 460: * direct path, with a contenience API that allows inspecting and
! 461: * accepting the streamed content.
! 462: *
! 463: *
! 464: * Here is an example on how to create an stream from a memory chunk:
! 465: * \code
! 466: * axlStream * stream;
! 467: * axlError * error;
! 468: *
! 469: * // create the stream and check result
! 470: * stream = axl_stream_new (source_content, size_content, -1, NULL, &error);
! 471: * if (stream == NULL) {
! 472: * printf ("An error was found: %s\n", axl_error_get (error));
! 473: * axl_error_free (error);
! 474: * return;
! 475: * }
! 476: *
! 477: * // stream created
! 478: * \endcode
! 479: *
! 480: * In the case an stream is required to parse a file descriptor
! 481: * (including a socket):
! 482: *
! 483: * \code
! 484: * stream = axl_stream_new (NULL, -1, NULL, fd, &error);
! 485: * \endcode
! 486: *
! 487: * You can also provide a file path to let the axl stream module to
! 488: * open the file and buffer it as it requires to consume characters:
! 489: *
! 490: * \code
! 491: * stream = axl_stream_new (NULL, -1, "c:/myFiles/document.xml", -1, &error);
! 492: * \endcode
! 493: *
! 494: *
! 495: * Once initialized the \ref axlStream object, you can use the
! 496: * following function to check and consume characters:
! 497: *
! 498: * - \ref axl_stream_inspect
! 499: * - \ref axl_stream_peek
! 500: * - \ref axl_stream_accept
! 501: *
! 502: * There alternatives APIs that allows to get the content until some
! 503: * patter is found (or a set of patterns):
! 504: *
! 505: * - \ref axl_stream_get_until
! 506: *
! 507: *
! 508: * @param stream_source A pointer to the memory where the data to be
! 509: * streamed is located.
! 510: *
! 511: * @param stream_size How many bytes are available to perform
! 512: * streaming. You can pass a -1 value to allow the function to
! 513: * calculate the stream source size (stream_source param).
! 514: *
! 515: * @param file_path Optional parameter to allow reading the stream
! 516: * from a file using the open API.
! 517: *
! 518: * @param fd_handler Optional parameter to allow reading the stream
! 519: * from a file descriptor, that could be a file, a socket, etc..
! 520: *
! 521: * @param error Optional \ref axlError reference where errors will be reported.
! 522: *
! 523: * @return A newly allocated stream instance that should be
! 524: * deallocated by using \ref axl_stream_free. The function could
! 525: * return a NULL value is received a NULL stream or a non positive
! 526: * stream size.
! 527: */
! 528: axlStream * axl_stream_new (const char * stream_source, int stream_size,
! 529: const char * file_path, int fd_handler,
! 530: axlError ** error)
! 531: {
! 532: axlStream * stream;
! 533: int fd;
! 534:
! 535: /* perform some environmental checkings */
! 536: if (file_path != NULL || (fd_handler > 0)) {
! 537: if (fd_handler < 0) {
! 538: /* a file handle */
! 539: if ((fd = open (file_path, O_RDONLY)) < 0) {
! 540: axl_log (LOG_DOMAIN, AXL_LEVEL_CRITICAL, "unable to open file a the location provided: %s, check location and permissions.", file_path);
! 541:
! 542: axl_error_new (-1, "unable to read file provided", NULL, error);
! 543: return NULL;
! 544: }
! 545: }else
! 546: fd = fd_handler;
! 547:
! 548: /* create the stream holder */
! 549: stream = axl_new (axlStream, 1);
! 550: stream->buffer_size = STREAM_BUFFER_SIZE;
! 551: stream->type = STREAM_FD;
! 552: stream->fd = fd;
! 553:
! 554: /* allocate 4k to perform streaming */
! 555: stream->stream = axl_new (char, stream->buffer_size + 1);
! 556: stream->temp = axl_new (char, stream->buffer_size + 1);
! 557:
! 558: /* prebuffer */
! 559: axl_stream_prebuffer (stream);
! 560: }else {
! 561: /* check chunk received */
! 562: if (stream_source == NULL) {
! 563: axl_error_new (-1, "Requested to open a stream without providing an memory chunk, file descriptor or a file path", NULL, error);
! 564: return NULL;
! 565: }
! 566:
! 567: /* check memory chunk size */
! 568: if (stream_size == -1)
! 569: stream_size = strlen (stream_source);
! 570:
! 571: /* create the stream holder */
! 572: stream = axl_new (axlStream, 1);
! 573: stream->buffer_size = stream_size;
! 574: stream->type = STREAM_MEM;
! 575:
! 576: /* copy source */
! 577: stream->stream = axl_new (char, stream_size + 1);
! 578: memcpy (stream->stream, stream_source, stream_size);
! 579: /* nullify the last entry to avoid problems with
! 580: printing functions and other APIs relaying on
! 581: finding \0 at the end of the string */
! 582: stream->stream[stream_size] = 0;
! 583:
! 584: /* set initial indicators */
! 585: stream->stream_size = stream_size;
! 586: }
! 587:
! 588: /* initilize common stream part */
! 589: stream->chunks = axl_new (char *, MAX_INSPECTED_CHUNKS + 1);
! 590: stream->lengths = axl_new (int, MAX_INSPECTED_CHUNKS + 1);
! 591:
! 592: /* return newly created stream */
! 593: return stream;
! 594: }
! 595:
! 596: /**
! 597: * @internal
! 598: *
! 599: * Internal implementation to support axl_stream_inspect and
! 600: * axl_stream_peek.
! 601: *
! 602: * @param stream The stream where the inspect operation will be
! 603: * performed.
! 604: *
! 605: * @param chunk The chunk to be used while performing the inspect
! 606: * operation.
! 607: *
! 608: * @param inspected_size The size for the chunk to be checked or -1 if
! 609: * a chunk size calculation is required.
! 610: *
! 611: * @param alsoAccept axl_true to make the function to accept stream
! 612: * that is properly inspected, axl_false if not.
! 613: *
! 614: * @return See \ref axl_stream_inspect.
! 615: */
! 616: #define axl_stream_common_inspect(i,stream,chunk,inspected_size,alsoAccept)\
! 617: if (inspected_size == -1)\
! 618: inspected_size = strlen (chunk);\
! 619: if (axl_stream_fall_outside (stream, inspected_size))\
! 620: return -1;\
! 621: i = 0;\
! 622: while (chunk [i] != 0 && (stream->stream + stream->stream_index) [i] != 0) {\
! 623: if (chunk [i] != (stream->stream + stream->stream_index) [i])\
! 624: return 0;\
! 625: i++;\
! 626: if (i == inspected_size) {\
! 627: stream->previous_inspect = inspected_size;\
! 628: if (alsoAccept) {\
! 629: axl_stream_accept (stream);\
! 630: }\
! 631: return 1;\
! 632: }\
! 633: }\
! 634: return 0
! 635:
! 636:
! 637: /**
! 638: * @brief Allows to perform an inspection of the given chunk on the
! 639: * given stream.
! 640: *
! 641: * The <i>chunk</i> will be checked to apper at the begining of the
! 642: * stream. This means that, having the current state of the stream,
! 643: * the chunk is checked to be found at the very begining of the
! 644: * stream.
! 645: *
! 646: * If the function succeed, an implict call to \ref axl_stream_accept
! 647: * is done. In the case you are only checking but no stream acceptance
! 648: * is required, use instead: \ref axl_stream_peek.
! 649: *
! 650: * @param stream The \ref axlStream where the operation will be
! 651: * performed.
! 652: *
! 653: * @param chunk The chunk that is expected to be found at the begin of the stream.
! 654: *
! 655: * @param inspected_size The size of the chunk provided to be inspected.
! 656: *
! 657: * @return The function returns the following values according to the result:
! 658: *
! 659: * - <b>0</b> if the chunk wasn't found inside the stream but no error was
! 660: * found.
! 661: *
! 662: * - <b>1</b> if the chunk is found inside the given stream.
! 663: *
! 664: * - <b>-1</b> means that no more stream is left to satify the operation.
! 665: *
! 666: * - <b>-2</b> means that the parameters received are wrong either
! 667: * because stream is a NULL reference or because chunk is the same.
! 668: */
! 669: int axl_stream_inspect (axlStream * stream, const char * chunk, int inspected_size)
! 670: {
! 671: int iterator;
! 672:
! 673: /* call to common implementation */
! 674: axl_stream_common_inspect (iterator, stream, chunk, inspected_size, axl_true);
! 675: }
! 676:
! 677: /**
! 678: * @brief Allows to check the provide char code at the given \ref
! 679: * axlStream, using optionally an offset to perform the check.
! 680: *
! 681: * @param stream The stream where the check operation will be
! 682: * implemented.
! 683: *
! 684: * @param value The value to check.
! 685: *
! 686: * @param offset The stream offset to apply to the check. Use 0 to not
! 687: * apply offset.
! 688: *
! 689: * @return \ref axl_true if the provided value is found at the current
! 690: * stream index (taking into consideration offset).
! 691: */
! 692: axl_bool axl_stream_inspect_code (axlStream * stream, char value, int offset)
! 693: {
! 694: axl_return_val_if_fail (stream, axl_false);
! 695:
! 696: /* check the value */
! 697: return stream->stream [stream->stream_index + offset] == value;
! 698: }
! 699:
! 700: /**
! 701: * @brief Allows to perform a stream inspection without automatically
! 702: * accept content properly inspected.
! 703: *
! 704: * @param stream The stream where the peek operation will be
! 705: * performed.
! 706: *
! 707: * @param chunk The chunk to lookup.
! 708: *
! 709: * @param inspected_size The size of the chunk provided to be
! 710: * inspected.
! 711: *
! 712: * @return See \ref axl_stream_inspect.
! 713: */
! 714: int axl_stream_peek (axlStream * stream, const char * chunk, int inspected_size)
! 715: {
! 716: int iterator;
! 717:
! 718: /* call to common implementation */
! 719: axl_stream_common_inspect (iterator, stream, chunk, inspected_size, axl_false);
! 720: }
! 721:
! 722: /**
! 723: * @brief Allows to perform several, not excluyen inspect operations,
! 724: * over the given stream.
! 725: *
! 726: * Here is an example:
! 727: * \code
! 728: * if (axl_stream_inspect_several (stream, // the stream
! 729: * 2, // two chunks to recognize
! 730: * "or", 2, // first chunk and its length
! 731: * "||", 2) > 0) { // second chunk and its length
! 732: * // chunk matched!!
! 733: * }
! 734: * \endcode
! 735: * @param stream The stream where the operation will be performed.
! 736: *
! 737: * @param chunk_num The chunk number to inspect.
! 738: *
! 739: * @return The function returns the following values:
! 740: *
! 741: * - <b>0</b>: if no chunk is found inside the given stream, according to the
! 742: * provided chunks.
! 743: *
! 744: * - <b>N</b>: is returned to denote that the Nth chunk was found.
! 745: *
! 746: * - <b>-1</b>: is returned if no more stream is left to satisfy the operation.
! 747: *
! 748: * - <b>-2</b>: means that the parameters received are wrong either because
! 749: * stream is NULL or any other parameter.
! 750: */
! 751: int axl_stream_inspect_several (axlStream * stream, int chunk_num, ...)
! 752: {
! 753: va_list args;
! 754: int iterator = 0;
! 755: char * chunk = NULL;
! 756: int length = 0;
! 757: int last_value = 0;
! 758:
! 759: axl_return_val_if_fail (stream, -1);
! 760: axl_return_val_if_fail (chunk_num > 0, -1);
! 761:
! 762: va_start (args, chunk_num);
! 763:
! 764: /* check each chunk */
! 765: while (iterator < chunk_num) {
! 766:
! 767: /* get the next chunk */
! 768: chunk = va_arg (args, char *);
! 769: length = va_arg (args, int);
! 770:
! 771: if (length == -1)
! 772: length = strlen (chunk);
! 773:
! 774: /* check the chunk read */
! 775: switch (axl_stream_inspect (stream, chunk, length)) {
! 776: case -2:
! 777: /* wrong parameter received */
! 778: last_value = -2;
! 779: break;
! 780: case -1:
! 781: /* there is no more stream left */
! 782: last_value = -1;
! 783: break;
! 784: case 0:
! 785: /* the chunk wasn't found, break and
! 786: * continue. */
! 787: break;
! 788: default:
! 789: /* the chunk was found */
! 790: va_end (args);
! 791: return (iterator + 1);
! 792: }
! 793:
! 794: /* update the iterator */
! 795: iterator ++;
! 796: }
! 797:
! 798: /* close va arg */
! 799: va_end (args);
! 800:
! 801: /* return that no chunk was found */
! 802: return last_value;
! 803: }
! 804:
! 805: /**
! 806: * @brief Accept previous inspected chunk to be consumed and moves
! 807: * current stream current the size equal to the chunk inspected.
! 808: *
! 809: * @param stream The stream where the byte inspected size will be
! 810: * accepted.
! 811: */
! 812: void axl_stream_accept (axlStream * stream)
! 813: {
! 814: axl_return_if_fail (stream);
! 815:
! 816: /* simple memory chunk parsing */
! 817: stream->stream_index += stream->previous_inspect;
! 818: stream->global_index += stream->previous_inspect;
! 819:
! 820: stream->previous_inspect = 0;
! 821: if (stream->last_chunk != NULL)
! 822: axl_free (stream->last_chunk);
! 823: stream->last_chunk = NULL;
! 824:
! 825: return;
! 826: }
! 827:
! 828: /**
! 829: * @brief Push new content at the begin of the stream.
! 830: *
! 831: * @param stream The stream that will be updated with new content.
! 832: *
! 833: * @param content The content to be added.
! 834: *
! 835: * @param size The size of the content to be added.
! 836: */
! 837: void axl_stream_push (axlStream * stream, const char * content, int size)
! 838: {
! 839: axl_return_if_fail (stream && content);
! 840:
! 841: /* place the content at the begin of the stream */
! 842: axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "calling to push the stream..");
! 843:
! 844: /* check if the current stream buffer could hold the pushed
! 845: * content plus the content that is already placed */
! 846: if (stream->stream_size < (stream->stream_size - stream->stream_index + size)) {
! 847: /* seems we can't hold the content at this moment, so, update the stream size */
! 848: stream->buffer_size = stream->stream_size - stream->stream_index + size;
! 849:
! 850: /* alloc a new temporal buffer */
! 851: axl_free (stream->temp);
! 852: stream->temp = axl_new (char, stream->buffer_size + 1);
! 853: memcpy (stream->temp, content, size);
! 854:
! 855: /* displace memory already read to be at the begining
! 856: * of the stream */
! 857: memcpy (stream->temp + size, stream->stream + stream->stream_index,
! 858: stream->stream_size - stream->stream_index);
! 859:
! 860: /* now realloc the buffer */
! 861: axl_free (stream->stream);
! 862: stream->stream = axl_new (char, stream->buffer_size + 1);
! 863:
! 864: /* now copy displaced content back to the stream */
! 865: memcpy (stream->stream, stream->temp,
! 866: (stream->stream_size - stream->stream_index) + size);
! 867: } else {
! 868:
! 869: /* check for the temporal buffer to be created */
! 870: if (stream->temp == NULL)
! 871: stream->temp = axl_new (char, stream->buffer_size + 1);
! 872:
! 873: /* copy the content */
! 874: memcpy (stream->temp, content, size);
! 875:
! 876: /* displace memory already read to be at the begining
! 877: * of the stream */
! 878: memcpy (stream->temp + size, stream->stream + stream->stream_index,
! 879: stream->stream_size - stream->stream_index);
! 880:
! 881: /* now copy displaced content back to the stream */
! 882: memcpy (stream->stream, stream->temp,
! 883: (stream->stream_size - stream->stream_index) + size);
! 884:
! 885: } /* end if */
! 886:
! 887: /* update the index to the positioned at the next byte
! 888: * available on the buffer */
! 889: stream->stream_size = (stream->stream_size - stream->stream_index) + size;
! 890:
! 891: /* reset the index */
! 892: stream->stream_index = 0;
! 893:
! 894: /* clean previous state */
! 895: axl_stream_accept (stream);
! 896:
! 897: return;
! 898: }
! 899:
! 900: /**
! 901: * @brief Allows to configure current index to be accepted by the
! 902: * stream.
! 903: *
! 904: * @param stream The stream where the operation will be performed.
! 905: *
! 906: * @param index Count to move internal stream index.
! 907: *
! 908: * NOTE: the function reset current internal state (by doing an
! 909: * implicit call to \ref axl_stream_accept).
! 910: */
! 911: void axl_stream_move (axlStream * stream, int index)
! 912: {
! 913: axl_return_if_fail (stream);
! 914:
! 915: axl_stream_accept (stream);
! 916: stream->stream_index = index;
! 917:
! 918: return;
! 919: }
! 920:
! 921: /**
! 922: * @brief Makes the current index to be moved the amount of bytes
! 923: * signaled by the parameter bytes.
! 924: *
! 925: * @param stream The stream to update.
! 926: * @param bytes The number of bytes to move the index.
! 927: */
! 928: void axl_stream_step (axlStream * stream, int bytes)
! 929: {
! 930: axl_return_if_fail (stream);
! 931: axl_return_if_fail (bytes >= 0);
! 932:
! 933: axl_stream_accept (stream);
! 934: stream->stream_index += bytes;
! 935:
! 936: return;
! 937: }
! 938:
! 939: /**
! 940: * @brief Returns the next chunk available on the stream.
! 941: *
! 942: * This function allows to get next available chunk, validating it
! 943: * with provided valid_chars variable, until the chunk provided are
! 944: * found.
! 945: *
! 946: * Currently, valid_chars is not used, so, the chunk returned is not
! 947: * validated against the value provided.
! 948: *
! 949: * As an example if it is required to get the encoding content, you
! 950: * could do the next call:
! 951: *
! 952: * \code
! 953: * // reference to the allocated result
! 954: * char * result;
! 955: *
! 956: * // chunk matched variable
! 957: * int chunk_matched;
! 958: *
! 959: * // get the next chunk until a " or ' is found
! 960: * result = axl_stream_get_until (stream, NULL, &chunk_matched, AXL_TRUE, 2, "\"", "'");
! 961: * \endcode
! 962: *
! 963: * Value returned from this function mustn't be deallocated. However,
! 964: * because the value returned is dinamically allocated by the
! 965: * function, you can avoid doing a double allocation operation by
! 966: * nullifying the internal reference to the result returned, making
! 967: * the caller the only owner of the reference returned. To do this
! 968: * use: \ref axl_stream_nullify with \ref LAST_CHUNK.
! 969: *
! 970: *
! 971: * @param stream The stream were the chunk will be extracted.
! 972: *
! 973: * @param valid_chars The valid set of characters, to validate content
! 974: * to be returned. Currently this is not implemented, so, you can
! 975: * provide a NULL value.
! 976: *
! 977: * @param chunk_matched An optional pointer to an integer to notify
! 978: * the chunk matched by the function. Chunk matching notification
! 979: * starts from 0 up to number of chunks to match - 1. If the end of
! 980: * the stream is reached, -2 is returned.
! 981: *
! 982: * @param accept_terminator While calling to this function, the
! 983: * terminator detected to stop the operation could also be accepted by
! 984: * the stream, making it not necessary to accept the terminator once
! 985: * the function have ended. However, this could be a problem while
! 986: * performing peeking code. You can provide a AXL_FALSE value to make the
! 987: * function to not accept the terminator found as to be consumed.
! 988: *
! 989: * @param chunk_num The number of chunks to be checked as a valid terminators.
! 990: *
! 991: * @return The chunk recognizied, not including the terminator that
! 992: * have made this operation to stop.
! 993: */
! 994: char * axl_stream_get_until (axlStream * stream,
! 995: char * valid_chars,
! 996: int * chunk_matched,
! 997: axl_bool accept_terminator,
! 998: int chunk_num, ...)
! 999: {
! 1000: char * result;
! 1001: va_list args;
! 1002:
! 1003: /* open the standard argument */
! 1004: va_start (args, chunk_num);
! 1005:
! 1006: /* call to get next chunk separated by the provided values */
! 1007: result = axl_stream_get_untilv (stream, valid_chars, chunk_matched, accept_terminator, NULL, chunk_num, args);
! 1008:
! 1009: /* close the standard argument */
! 1010: va_end (args);
! 1011:
! 1012: /* return value read */
! 1013: return result;
! 1014: }
! 1015:
! 1016: /**
! 1017: * @brief Works the same way like axl_strteam_get_until but wihtout
! 1018: * allocating the memory returned, and filling the size for the chunk
! 1019: * returned in result_size reference.
! 1020: *
! 1021: * @param stream The stream where the operation will be performed.
! 1022: *
! 1023: * @param valid_chars The valid chars reference to match (currently
! 1024: * not implemented).
! 1025: *
! 1026: * @param chunk_matched The chunk matched reference
! 1027: *
! 1028: * @param accept_terminator Configure if the terminator should be
! 1029: * accepted or not.
! 1030: *
! 1031: * @param result_size The variable where the result size will be
! 1032: * returned. This variable is not optional. It must be configured to
! 1033: * hold the size of the content returned. If you provided a NULL
! 1034: * reference to this value then the function will fail.
! 1035: *
! 1036: * @param chunk_num The number of chunks to match.
! 1037: *
! 1038: * @return A reference to the internal stream copy. The reference
! 1039: * returned must not be deallocated.
! 1040: *
! 1041: * NOTE: This function have a particular function that could produce
! 1042: * not desired results. Because the stream returns a reference to the
! 1043: * current allocated stream, if nullifies the last position (\\0) to
! 1044: * avoid memory problems with printf APIs and any other code that
! 1045: * relay on the fact that C strings are NULL terminated. If the
! 1046: * content immediately following to the string returned is meaningful,
! 1047: * then you can't use this function. Example:
! 1048: *
! 1049: * \code
! 1050: * stream: CONTENTCONTENT2
! 1051: * ^
! 1052: * |
! 1053: * +--- stream index
! 1054: *
! 1055: * calling to axl_stream_get_until_ref (stream, NULL, NULL, axl_false,
! 1056: * &size, 1, "CONTENT");
! 1057: *
! 1058: * while cause stream: CONTENT\0ONTENT2
! 1059: * ^
! 1060: * |
! 1061: * +--- stream index
! 1062: *
! 1063: * and the function returning "CONTENT". See the fact that the
! 1064: * next "C" from the word CONTENT2 is nullified.
! 1065: *
! 1066: * \endcode
! 1067: *
! 1068: * An indication that this function is not what you want is that you
! 1069: * are not accepting the terminator (accept_terminator=axl_false).
! 1070: */
! 1071: char * axl_stream_get_until_ref (axlStream * stream,
! 1072: char * valid_chars,
! 1073: int * chunk_matched,
! 1074: axl_bool accept_terminator,
! 1075: int * result_size,
! 1076: int chunk_num, ...)
! 1077: {
! 1078: char * result;
! 1079: va_list args;
! 1080:
! 1081: axl_return_val_if_fail (result_size, NULL);
! 1082:
! 1083: /* open the standard argument */
! 1084: va_start (args, chunk_num);
! 1085:
! 1086: /* call to get next chunk separated by the provided values */
! 1087: result = axl_stream_get_untilv (stream, valid_chars, chunk_matched, accept_terminator, result_size, chunk_num, args);
! 1088:
! 1089: /* close the standard argument */
! 1090: va_end (args);
! 1091:
! 1092: /* return value read */
! 1093: return result;
! 1094: }
! 1095:
! 1096: /**
! 1097: * @brief Allows to get the next string until the separators provided
! 1098: * are found or the end of the stream memory is reached.
! 1099: *
! 1100: * \ref axlStream type was designed to support parsing xml
! 1101: * documents. This documents have elements that allows to now where
! 1102: * the input has finished. Howerver, \ref axlStream abstraction has
! 1103: * showed to be powerful enough to be usable to parse other kinds of
! 1104: * elements that don't have lexical terminators to let the user to
! 1105: * provide that chunk to be matched.
! 1106: *
! 1107: * In those cases, this function allows to perform the same function
! 1108: * as \ref axl_stream_get_until but also checking, and using, as
! 1109: * terminator the end of the stream.
! 1110: *
! 1111: * This allows to parse expressions like:
! 1112: * \code
! 1113: * int chunk_matched;
! 1114: * axlStream * stream;
! 1115: * char * string;
! 1116: *
! 1117: * // create the stream
! 1118: * stream = axl_stream_new ("array.value", -1, NULL, -1, &error);
! 1119: *
! 1120: * // parse first array identifier
! 1121: * string = axl_stream_get_until_zero (stream, NULL, &chunk_matched,
! 1122: * axl_false, 2, "[", ".", NULL);
! 1123: *
! 1124: * // received "array"
! 1125: *
! 1126: * // parse again
! 1127: * string = axl_stream_get_until_zero (stream, NULL, &chunk_matched,
! 1128: * axl_false, 2, "[", ".", NULL);
! 1129: *
! 1130: * // received "value" and chunk_matched == (-2)
! 1131: * \endcode
! 1132: *
! 1133: *
! 1134: * @param stream The stream were the chunk will be extracted.
! 1135: *
! 1136: * @param valid_chars The valid set of characters, to validate content
! 1137: * to be returned. Currently this is not implemented, so, you can
! 1138: * provide a NULL value.
! 1139: *
! 1140: * @param chunk_matched An optional pointer to an integer to notify
! 1141: * the chunk matched by the function. Chunk matching notification
! 1142: * starts from 0 up to number of chunks to match - 1. If the end of
! 1143: * the stream is reached while searching for the content to match,
! 1144: * chunk_matched is configured to -2.
! 1145: *
! 1146: * @param accept_terminator While calling to this function, the
! 1147: * terminator detected to stop the operation could also be accepted by
! 1148: * the stream, making it not necessary to accept the terminator once
! 1149: * the function have ended. However, this could be a problem while
! 1150: * performing peeking code. You can provide a AXL_FALSE value to make the
! 1151: * function to not accept the terminator found as to be consumed.
! 1152: *
! 1153: * @param chunk_num The number of chunks to be checked as a valid terminators.
! 1154: *
! 1155: * @return The chunk recognizied, not including the terminator that
! 1156: * have made this operation to stop. Rembember to check the
! 1157: * chunk_matched variable to be equal to -2. This will mean that the
! 1158: * string returned doesn't match any terminator provided because end
! 1159: * of the stream was reached while looking for them.
! 1160: */
! 1161: char * axl_stream_get_until_zero (axlStream * stream,
! 1162: char * valid_chars,
! 1163: int * chunk_matched,
! 1164: axl_bool accept_terminator,
! 1165: int chunk_num, ...)
! 1166: {
! 1167: char * result;
! 1168: va_list args;
! 1169:
! 1170: /* open the standard argument */
! 1171: va_start (args, chunk_num);
! 1172:
! 1173: /* call to get next chunk separated by the provided values */
! 1174: stream->zero = axl_true;
! 1175: result = axl_stream_get_untilv (stream, valid_chars, chunk_matched, accept_terminator, NULL, chunk_num, args);
! 1176: stream->zero = axl_false;
! 1177:
! 1178: /* close the standard argument */
! 1179: va_end (args);
! 1180:
! 1181: /* return value read */
! 1182: return result;
! 1183: }
! 1184:
! 1185: char * axl_stream_get_until_ref_zero (axlStream * stream,
! 1186: char * valid_chars,
! 1187: int * chunk_matched,
! 1188: axl_bool accept_terminator,
! 1189: int * result_size,
! 1190: int chunk_num, ...)
! 1191: {
! 1192: char * result;
! 1193: va_list args;
! 1194:
! 1195: /* open the standard argument */
! 1196: va_start (args, chunk_num);
! 1197:
! 1198: /* call to get next chunk separated by the provided values */
! 1199: stream->zero = axl_true;
! 1200: result = axl_stream_get_untilv (stream, valid_chars, chunk_matched, accept_terminator, result_size, chunk_num, args);
! 1201: stream->zero = axl_false;
! 1202:
! 1203: /* close the standard argument */
! 1204: va_end (args);
! 1205:
! 1206: /* return value read */
! 1207: return result;
! 1208: }
! 1209:
! 1210: /**
! 1211: * @brief Allows to configure the handler to be executed to alloc
! 1212: * memory for the axl_stream_get_until* API.
! 1213: *
! 1214: * @param stream The stream to configure with the alloc function.
! 1215: *
! 1216: * @param handler The handler to be called when the streams requires
! 1217: * to alloc memory.
! 1218: *
! 1219: * @param data User defined pointer to be called to the allocator
! 1220: * function defined by the <b>handler</b> parameter.
! 1221: */
! 1222: void axl_stream_set_buffer_alloc (axlStream * stream,
! 1223: axlStreamAlloc handler,
! 1224: axlPointer data)
! 1225: {
! 1226: axl_return_if_fail (stream);
! 1227:
! 1228: /* just configure the alloc handler */
! 1229: stream->alloc = handler;
! 1230: stream->alloc_data = data;
! 1231:
! 1232: return;
! 1233: }
! 1234:
! 1235: /**
! 1236: * @brief Allows to nullify the internal reference of the stream,
! 1237: * making that reference to be not deallocated once the stream is
! 1238: * moving.
! 1239: *
! 1240: * This is mainly used to reduce the malloc/free round trip while
! 1241: * using the stream abstraction, making the stream received from the
! 1242: * memory chunk to be allocated only once, avoiding the double
! 1243: * allocate-free cycle.
! 1244: *
! 1245: * @param stream The \ref axlStream where the operation will be
! 1246: * performed.
! 1247: *
! 1248: * @param item The item to nullify.
! 1249: */
! 1250: void axl_stream_nullify (axlStream * stream,
! 1251: NullifyItem item)
! 1252: {
! 1253: /* do not operate if a null stream reference is received */
! 1254: axl_return_if_fail (stream);
! 1255:
! 1256: switch (item) {
! 1257: case LAST_CHUNK:
! 1258: stream->last_chunk = NULL;
! 1259: break;
! 1260: case LAST_NEAR_TO:
! 1261: stream->last_near_to = NULL;
! 1262: break;
! 1263: case LAST_GET_FOLLOWING:
! 1264: stream->last_get_following = NULL;
! 1265: break;
! 1266: }
! 1267:
! 1268: /* nothing more to do here */
! 1269: return;
! 1270: }
! 1271:
! 1272: /**
! 1273: * @internal
! 1274: *
! 1275: * Wide implementation for axl stream get until (which checks for
! 1276: * every index chunks provided instead of checking the first one until
! 1277: * a prebuffer operation is required).
! 1278: */
! 1279: char * __axl_stream_get_untilv_wide (axlStream * stream, va_list args)
! 1280: {
! 1281:
! 1282: int iterator = 0;
! 1283: int index = 0;
! 1284: int _index = 0;
! 1285: int length = 0;
! 1286: int max_length = 0;
! 1287: axl_bool matched;
! 1288: char * string = NULL;
! 1289: axl_bool match_empty = axl_false;
! 1290: int empty_index = 0;
! 1291:
! 1292: /* get how many bytes remains to be read */
! 1293: int remains;
! 1294:
! 1295: /* set current matched value */
! 1296: stream->chunk_matched = -1;
! 1297:
! 1298: /* iterate over the chunk list */
! 1299: while (iterator < stream->chunk_num) {
! 1300:
! 1301: /* get the chunk */
! 1302: stream->chunks [iterator] = va_arg (args, char *);
! 1303:
! 1304: /* check if we have to match the emtpy string, and
! 1305: * don't install the value to be matched */
! 1306: if (axl_cmp (stream->chunks[iterator], " ")) {
! 1307: match_empty = axl_true;
! 1308:
! 1309: /* reset the length size to detect an emtpy
! 1310: * string */
! 1311: stream->lengths [iterator] = 0;
! 1312: empty_index = iterator;
! 1313: }else {
! 1314: /* get the size */
! 1315: stream->lengths [iterator] = strlen (stream->chunks [iterator]);
! 1316: }
! 1317:
! 1318: /* get current length */
! 1319: if (stream->lengths [iterator] > max_length)
! 1320: max_length = stream->lengths [iterator];
! 1321:
! 1322: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "found matching chunk: '%s' length: %d",
! 1323: stream->chunks[iterator], stream->lengths [iterator]);
! 1324:
! 1325: /* update index */
! 1326: iterator ++;
! 1327: }
! 1328:
! 1329: /* calculate how many bytes ara available */
! 1330: remains = stream->stream_size - stream->stream_index;
! 1331:
! 1332: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "remaining data to be inspected: %d bytes (stream->stream-size=%d, stream->stream-index=%d)",
! 1333: remains, stream->stream_size, stream->stream_index);
! 1334:
! 1335: /* now we have chunks to lookup, stream until get the stream
! 1336: * limited by the chunks received. */
! 1337: do {
! 1338:
! 1339: /* decrease remain bytes to be read until perform a
! 1340: * prebuffer operation */
! 1341: remains--;
! 1342:
! 1343: /* only prebuffer for this type of stream */
! 1344: if (stream->type == STREAM_FD) {
! 1345:
! 1346: /* check if the index is falling out side the buffer boundaries */
! 1347: if (remains < 0) {
! 1348:
! 1349: if (! axl_stream_prebuffer (stream)) {
! 1350: /* check if a call to zero was found */
! 1351: if (stream->zero) {
! 1352: /* flag that chunk matched
! 1353: * will be -2 */
! 1354: stream->chunk_matched = -2;
! 1355: goto matched_return_result;
! 1356: } /* end if */
! 1357: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "failed while prebuffer (stream->type = %d)", stream->type);
! 1358:
! 1359: return NULL;
! 1360: }
! 1361:
! 1362: /* update remains value but this time removing
! 1363: * one unit (the unit to be consumed at the
! 1364: * next sentence) */
! 1365: remains = stream->stream_size - index - 1;
! 1366:
! 1367: /* work around: because the index is updated
! 1368: * at the end of the loop, it is required to
! 1369: * decrease the index in one unit in the case
! 1370: * a prebuffer operation happens */
! 1371: if (index > 0) {
! 1372: index--;
! 1373: }
! 1374:
! 1375: } /* end if */
! 1376: }
! 1377:
! 1378: /* check we don't get out side the memory */
! 1379: if (stream->type == STREAM_MEM) {
! 1380: if (remains < 0) {
! 1381:
! 1382: /* check for zero stream ended
! 1383: * support */
! 1384: if (stream->zero) {
! 1385: /* flag that chunk matched
! 1386: * will be -2 */
! 1387: stream->chunk_matched = -2;
! 1388: goto matched_return_result;
! 1389: }
! 1390:
! 1391: /* seems there is no more room to
! 1392: * read */
! 1393: return NULL;
! 1394: } /* end if */
! 1395: } /* end if */
! 1396:
! 1397:
! 1398: /* compare chunks received for each index increased
! 1399: * one step */
! 1400: init_get_until:
! 1401: _index = stream->stream_index + index;
! 1402: matched = axl_false;
! 1403: iterator = 0;
! 1404:
! 1405: /* before iterating, check if we have to match the
! 1406: * empty string */
! 1407: if (match_empty) {
! 1408: /* check for a white space item */
! 1409: if ((stream->stream[_index] == ' ') ||
! 1410: (stream->stream[_index] == '\n') ||
! 1411: (stream->stream[_index] == '\t') ||
! 1412: (stream->stream[_index] == '\r')) {
! 1413:
! 1414: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "matched by white space value matched_chunk=%d",
! 1415: iterator);
! 1416:
! 1417: /* string matched */
! 1418: length = 1;
! 1419: matched = axl_true;
! 1420: iterator = empty_index;
! 1421: }
! 1422: } /* end if */
! 1423:
! 1424: /* the empty string wasn't matched, now check for the
! 1425: * rest of chunks */
! 1426: while ((! matched) && (iterator < stream->chunk_num)) {
! 1427:
! 1428: /* get current length for the chunk to check */
! 1429: length = stream->lengths [iterator];
! 1430:
! 1431: /* check the length returned */
! 1432: matched = axl_false;
! 1433: if (length > 0 && ((_index + length) <= stream->stream_size)) {
! 1434:
! 1435: /* try to figure out if the next
! 1436: * string match */
! 1437: if ((stream->chunks [iterator][0] ==
! 1438: stream->stream [_index])) {
! 1439:
! 1440: if ((length == 1) ||
! 1441: (axl_memcmp (stream->chunks [iterator] + 1, stream->stream + _index + 1, length -1))) {
! 1442: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "matched as normal situation.. at index=%d (stream size=%d)",
! 1443: stream->stream_index + _index + 1, stream->stream_size);
! 1444: /* flag as matched */
! 1445: matched = axl_true;
! 1446: } /* end if */
! 1447: } /* end if */
! 1448: } /* end if */
! 1449:
! 1450: /* check if we have found the chunk we were looking */
! 1451: if (! matched) {
! 1452: /* update iterator */
! 1453: iterator ++;
! 1454: }
! 1455: } /* end while */
! 1456:
! 1457: /* check that the function have found a chunk */
! 1458: if (matched) {
! 1459: /* check for matching a more specific
! 1460: * terminal than a general */
! 1461: if ((length < max_length) &&
! 1462: ((_index + length) == stream->stream_size)) {
! 1463: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "detected possible false positive");
! 1464:
! 1465: /* do a prebuffer operation,
! 1466: * and if success, try to
! 1467: * check again all chunks at
! 1468: * the current index */
! 1469: if (axl_stream_prebuffer (stream))
! 1470: goto init_get_until;
! 1471: }
! 1472:
! 1473: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "matched_chunk=%d", iterator);
! 1474:
! 1475: /* report which is the chunk being
! 1476: * matched by the expresion */
! 1477: stream->chunk_matched = iterator;
! 1478:
! 1479: matched_return_result:
! 1480:
! 1481: /* result is found from last stream
! 1482: * index read up to index */
! 1483: if (stream->last_chunk != NULL) {
! 1484: axl_free (stream->last_chunk);
! 1485: stream->last_chunk = NULL;
! 1486: }
! 1487:
! 1488: /* get a copy to the chunk to be returned */
! 1489: if (! stream->result_size) {
! 1490: if (stream->alloc != NULL)
! 1491: stream->last_chunk = stream->alloc (index + 1, stream->alloc_data);
! 1492: else
! 1493: stream->last_chunk = axl_new (char, index + 1);
! 1494: memcpy (stream->last_chunk, stream->stream + stream->stream_index, index);
! 1495: }else {
! 1496: /* *result_size = index;*/
! 1497: stream->result_size = index;
! 1498: string = stream->stream + stream->stream_index;
! 1499:
! 1500: /* set a termination mark */
! 1501: string [ index ] = 0;
! 1502: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG,
! 1503: "Nullify internally index=%d to avoid printf problems", index);
! 1504: }
! 1505:
! 1506: /* in the case a memory chunk is being read */
! 1507: if (stream->accept_terminator)
! 1508: stream->stream_index += length;
! 1509: stream->stream_index += index;
! 1510: stream->global_index += index;
! 1511: stream->previous_inspect = 0;
! 1512:
! 1513:
! 1514: /* return allocated result */
! 1515: if (! stream->result_size)
! 1516: return stream->last_chunk;
! 1517:
! 1518: /* return reference result */
! 1519: return string;
! 1520: } /* end if */
! 1521:
! 1522: /* it seems that the chunk wasn't found */
! 1523: index++;
! 1524:
! 1525: }while (axl_true);
! 1526:
! 1527: /* return a NULL chunk. */
! 1528: return NULL;
! 1529: }
! 1530:
! 1531: /**
! 1532: * @brief Allows to perform the same operation like \ref
! 1533: * axl_stream_get_untilv but providing an already initialized and
! 1534: * opened std arg.
! 1535: *
! 1536: * This function is in fact, used by \ref axl_stream_get_untilv.
! 1537: *
! 1538: * @param stream The stream where the operation will be peformed.
! 1539: *
! 1540: * @param valid_chars The valid chars set to be used while reading
! 1541: * data.
! 1542: *
! 1543: * @param chunk_matched An optional value where the matched chunk will
! 1544: * be reported.
! 1545: *
! 1546: * @param accept_terminator Configure if terminator read should be
! 1547: * accepted or only the chunk read.
! 1548: *
! 1549: * @param result_size Allows to notify the caller with the chunk size
! 1550: * that is being returned by the function.
! 1551: *
! 1552: * @param chunk_num How many terminators are configured.
! 1553: *
! 1554: * @param args The list of terminators.
! 1555: *
! 1556: * @return The chunk read or NULL if fails.
! 1557: */
! 1558: char * axl_stream_get_untilv (axlStream * stream,
! 1559: char * valid_chars,
! 1560: int * chunk_matched,
! 1561: axl_bool accept_terminator,
! 1562: int * result_size,
! 1563: int chunk_num,
! 1564: va_list args)
! 1565: {
! 1566: char * result;
! 1567:
! 1568:
! 1569: /* check max inspected chunks */
! 1570: if (chunk_num > MAX_INSPECTED_CHUNKS) {
! 1571: __axl_log (LOG_DOMAIN, AXL_LEVEL_CRITICAL, "unable to parse stream for the number of chunks to recognize. Max number supported is %d, but received %d",
! 1572: MAX_INSPECTED_CHUNKS, stream->chunk_num);
! 1573: return NULL;
! 1574: }
! 1575:
! 1576: /* configure variables for the operation */
! 1577: stream->valid_chars = valid_chars;
! 1578: stream->accept_terminator = accept_terminator;
! 1579: stream->result_size = (result_size != NULL);
! 1580: stream->chunk_num = chunk_num;
! 1581:
! 1582: /* call to current implementation */
! 1583: result = __axl_stream_get_untilv_wide (stream, args);
! 1584:
! 1585: /* check for returning references */
! 1586: if (result_size != NULL)
! 1587: *result_size = stream->result_size;
! 1588: if (chunk_matched != NULL)
! 1589: *chunk_matched = stream->chunk_matched;
! 1590:
! 1591: /* return string matched */
! 1592: return result;
! 1593: }
! 1594:
! 1595:
! 1596: /**
! 1597: * @brief Returns current index status for the given stream.
! 1598: *
! 1599: * This function could be used to get current index being read for the
! 1600: * stream received.
! 1601: *
! 1602: * @param stream The stream where the index will be reported.
! 1603: *
! 1604: * @return The index or -1 if fails.
! 1605: */
! 1606: int axl_stream_get_index (axlStream * stream)
! 1607: {
! 1608: axl_return_val_if_fail (stream, -1);
! 1609:
! 1610: return stream->stream_index;
! 1611: }
! 1612:
! 1613: /**
! 1614: * @brief Returns current global index for the device being streamed.
! 1615: *
! 1616: * @param stream The stream where the data is being requested.
! 1617: *
! 1618: * @return The index or -1 if fails.
! 1619: */
! 1620: int axl_stream_get_global_index (axlStream * stream)
! 1621: {
! 1622: axl_return_val_if_fail (stream, -1);
! 1623:
! 1624: return stream->global_index;
! 1625: }
! 1626:
! 1627: /**
! 1628: * @brief Allows to get current stream size.
! 1629: *
! 1630: * @param stream The stream where the stream size will be returned.
! 1631: *
! 1632: * @return The stream size or -1 if fails.
! 1633: */
! 1634: int axl_stream_get_size (axlStream * stream)
! 1635: {
! 1636: axl_return_val_if_fail (stream, -1);
! 1637:
! 1638: return stream->stream_size;
! 1639: }
! 1640:
! 1641: /**
! 1642: * @brief Allows to get current status of the given stream, taking the
! 1643: * current index, getting an amount of <b>count</b> bytes before and
! 1644: * after the given index.
! 1645: *
! 1646: * This function is mainly used to get a piece of the stream at the
! 1647: * given position while reporting errors. This allows to show the
! 1648: * piece of xml that is failing.
! 1649: *
! 1650: * The string return must not be deallocated. Value returned is
! 1651: * actually managed by the stream object associated.
! 1652: *
! 1653: * @param stream The stream where the near to operation will be performed.
! 1654: * @param count The amount of bytes to take.
! 1655: *
! 1656: * @return A string that is taken counting bytes with provided
! 1657: * <b>count</b> value starting from the index. Stream provided must be
! 1658: * not NULL and count value must be greater than 0.
! 1659: */
! 1660: const char * axl_stream_get_near_to (axlStream * stream, int count)
! 1661: {
! 1662: int first_index;
! 1663: int last_index;
! 1664:
! 1665: axl_return_val_if_fail (stream, NULL);
! 1666: axl_return_val_if_fail (count > 0, NULL);
! 1667:
! 1668: /* get first index */
! 1669: if ((stream->stream_index - count) <= 0)
! 1670: first_index = 0;
! 1671: else
! 1672: first_index = stream->stream_index - count;
! 1673:
! 1674: /* get last index */
! 1675: if ((stream->stream_index + count) >= (stream->stream_size - 1) )
! 1676: last_index = (stream->stream_size) - first_index;
! 1677: else
! 1678: last_index = (stream->stream_index + count) - first_index;
! 1679:
! 1680: /* release previous near to chunk */
! 1681: if (stream->last_near_to != NULL)
! 1682: axl_free (stream->last_near_to);
! 1683:
! 1684: stream->last_near_to = axl_new (char, last_index + 1);
! 1685: memcpy (stream->last_near_to, stream->stream + first_index, last_index);
! 1686:
! 1687: /* return current near to operation */
! 1688: return stream->last_near_to;
! 1689:
! 1690: }
! 1691:
! 1692: /**
! 1693: * @brief Allows to get the following <b>count</b> bytes read from the
! 1694: * stream.
! 1695: *
! 1696: * @param stream The stream where the operation will be performed.
! 1697: * @param count How many bytes to get from the stream.
! 1698: *
! 1699: * @return A string referece, containing the first <b>count</b> bytes
! 1700: * or NULL if fails. Reference returned shouldn't be deallocated.
! 1701: */
! 1702: const char * axl_stream_get_following (axlStream * stream, int count)
! 1703: {
! 1704: axl_return_val_if_fail (stream, NULL);
! 1705:
! 1706: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "getting next characters from stream: index=%d size=%d",
! 1707: stream->stream_index, stream->stream_size);
! 1708:
! 1709: /* check index */
! 1710: if (stream->stream_index >= stream->stream_size)
! 1711: return NULL;
! 1712:
! 1713: if ((count + stream->stream_index) > stream->stream_size) {
! 1714: count = stream->stream_size - stream->stream_index;
! 1715: }
! 1716:
! 1717: /* free previously allocated memory */
! 1718: if (stream->last_get_following != NULL)
! 1719: axl_free (stream->last_get_following);
! 1720:
! 1721: /* copy stream content */
! 1722: stream->last_get_following = axl_new (char, count + 1);
! 1723: memcpy (stream->last_get_following, stream->stream + stream->stream_index, count);
! 1724:
! 1725: /* return reference created */
! 1726: return stream->last_get_following;
! 1727: }
! 1728:
! 1729: typedef struct _AxlStreamAssociatedData {
! 1730: axlPointer data;
! 1731: axlDestroyFunc destroy_func;
! 1732: axl_bool free_on_finish;
! 1733: }AxlStreamAssociatedData;
! 1734:
! 1735:
! 1736: /**
! 1737: * @internal
! 1738: *
! 1739: * Internal deallocation function to reclaim memory used by the \ref
! 1740: * AxlStreamAssociatedData.
! 1741: *
! 1742: * @param data The data to be deallocated.
! 1743: */
! 1744: void __stream_associated_data_free (AxlStreamAssociatedData * data)
! 1745: {
! 1746: /* do nothing if NULL is received */
! 1747: if (data == NULL)
! 1748: return;
! 1749:
! 1750: /* destroy associated data used provided destroy function */
! 1751: if (data->destroy_func != NULL && data->data != NULL)
! 1752: data->destroy_func (data->data);
! 1753:
! 1754: /* now free the node it self */
! 1755: axl_free (data);
! 1756:
! 1757: return;
! 1758: }
! 1759:
! 1760: /**
! 1761: * @brief Associates the given \ref axlPointer with the given stream to be
! 1762: * life-time dependant.
! 1763: *
! 1764: * While performing the XML parsing, errors will be produced. This
! 1765: * function ensures that the axlDoc document will be released if the
! 1766: * stream is also released.
! 1767: *
! 1768: * This not only reduces the possibility to produce a memory leak also
! 1769: * allows to write less code.
! 1770: *
! 1771: * Once the stream is not useful and it is required to be released,
! 1772: * but not doing so with the \ref axlDoc instance, a call to \ref
! 1773: * axl_stream_unlink is also required.
! 1774: *
! 1775: * @param stream The axlStream where the document will be linked to.
! 1776: *
! 1777: * @param element The element to link (may a axlDoc or a axlDtd).
! 1778: *
! 1779: * @param func The function to call once the stream is released.
! 1780: */
! 1781: void axl_stream_link (axlStream * stream,
! 1782: axlPointer element,
! 1783: axlDestroyFunc func)
! 1784: {
! 1785: /* call to base implementation */
! 1786: axl_stream_link_full (stream, element, func, axl_false);
! 1787:
! 1788: return;
! 1789: }
! 1790:
! 1791: /**
! 1792: * @brief Allows to associate data references with a destroy function,
! 1793: * like \ref axl_stream_link, but ensuring the object reference will
! 1794: * be released once finished the axl stream, no mather if the
! 1795: * application code calls to \ref axl_stream_unlink.
! 1796: *
! 1797: * @param stream The axlStream where the document will be linked to.
! 1798: *
! 1799: * @param element The element to link (may a axlDoc or a axlDtd).
! 1800: *
! 1801: *
! 1802: * @param func The function to call once the stream is released.
! 1803: *
! 1804: * @param free_on_finish axl_true to make the reference to be released on
! 1805: * \ref axlStream deallocation. Providing \ref axl_false to this value is
! 1806: * equivalent to call to \ref axl_stream_link directly.
! 1807: */
! 1808: void axl_stream_link_full (axlStream * stream,
! 1809: axlPointer element,
! 1810: axlDestroyFunc func,
! 1811: axl_bool free_on_finish)
! 1812: {
! 1813: AxlStreamAssociatedData * data;
! 1814: axl_return_if_fail (stream);
! 1815: axl_return_if_fail (element);
! 1816: axl_return_if_fail (func);
! 1817:
! 1818: /* that's all */
! 1819: if (stream->elements_linked == NULL)
! 1820: stream->elements_linked = axl_list_new (axl_list_always_return_1,
! 1821: (axlDestroyFunc) __stream_associated_data_free);
! 1822:
! 1823: /* create the data to be stored */
! 1824: data = axl_new (AxlStreamAssociatedData, 1);
! 1825: data->data = element;
! 1826: data->destroy_func = func;
! 1827: data->free_on_finish = free_on_finish;
! 1828:
! 1829: /* add the item to be destroy once the stream is unrefered */
! 1830: axl_list_add (stream->elements_linked, data);
! 1831:
! 1832: return;
! 1833: }
! 1834:
! 1835: /**
! 1836: * @brief Unlinks the associated \ref axlDoc instance.
! 1837: *
! 1838: * @param stream The stream where the operation will be performed.
! 1839: */
! 1840: void axl_stream_unlink (axlStream * stream)
! 1841: {
! 1842: int iterator;
! 1843: AxlStreamAssociatedData * data;
! 1844:
! 1845: axl_return_if_fail (stream);
! 1846:
! 1847: /* clear document association */
! 1848: iterator = 0;
! 1849: while (iterator < axl_list_length (stream->elements_linked)) {
! 1850: /* get a referece to the node to destroy */
! 1851: data = axl_list_get_nth (stream->elements_linked, iterator);
! 1852: /* clear it */
! 1853: if (! data->free_on_finish) {
! 1854: data->data = NULL;
! 1855: data->destroy_func = NULL;
! 1856: }
! 1857: iterator++;
! 1858: }
! 1859: return;
! 1860: }
! 1861:
! 1862: /**
! 1863: * @brief Allows to deallocate memory used by the \ref axlStream
! 1864: * received.
! 1865: *
! 1866: * @param stream The stream to be deallocated.
! 1867: */
! 1868: void axl_stream_free (axlStream * stream)
! 1869: {
! 1870: axl_return_if_fail (stream);
! 1871:
! 1872: /* release memory */
! 1873: axl_free (stream->stream);
! 1874:
! 1875: /* release associated document is defined. */
! 1876: if (stream->elements_linked)
! 1877: axl_list_free (stream->elements_linked);
! 1878:
! 1879: /* releaset last chunk */
! 1880: if (stream->last_chunk != NULL)
! 1881: axl_free (stream->last_chunk);
! 1882:
! 1883: /* releaset last near to */
! 1884: if (stream->last_near_to != NULL)
! 1885: axl_free (stream->last_near_to);
! 1886:
! 1887: /* releaset last get following */
! 1888: if (stream->last_get_following != NULL)
! 1889: axl_free (stream->last_get_following);
! 1890:
! 1891: if (stream->fd > 0) {
! 1892: /* close file descriptor if defined */
! 1893: close (stream->fd);
! 1894: }
! 1895:
! 1896: /* free memory allocated for chunk matching */
! 1897: axl_free (stream->chunks);
! 1898:
! 1899: /* free lengths */
! 1900: axl_free (stream->lengths);
! 1901:
! 1902: /* free temporal buffer */
! 1903: axl_free (stream->temp);
! 1904: axl_free (stream->decode_temp);
! 1905: axl_free (stream->source_encoding);
! 1906:
! 1907: /* release memory allocated by the stream received. */
! 1908: axl_free (stream);
! 1909:
! 1910: return;
! 1911: }
! 1912:
! 1913:
! 1914: /**
! 1915: * @brief Allows to check if the given chunk is a white space in the
! 1916: * same of the XML 1.0 Third edition.
! 1917: *
! 1918: * The XML standard understand the "white space", also reffered as S,
! 1919: * as the following characters: \\x20 (the white space itself), \\n, \\r
! 1920: * and \\t.
! 1921: *
! 1922: * This function allows to check if the given chunk contains a white
! 1923: * space, in the previous sense.
! 1924: *
! 1925: * @param chunk The chunk to check
! 1926: *
! 1927: * @return axl_true if the chunk contains a white space or axl_false
! 1928: * if not.
! 1929: */
! 1930: axl_bool axl_stream_is_white_space (char * chunk)
! 1931: {
! 1932: /* do not complain about receive a null refernce chunk */
! 1933: if (chunk == NULL)
! 1934: return axl_false;
! 1935:
! 1936: if (chunk[0] == ' ')
! 1937: return axl_true;
! 1938: if (chunk[0] == '\n')
! 1939: return axl_true;
! 1940: if (chunk[0] == '\t')
! 1941: return axl_true;
! 1942: if (chunk[0] == '\r')
! 1943: return axl_true;
! 1944:
! 1945: /* no white space was found */
! 1946: return axl_false;
! 1947: }
! 1948:
! 1949: /**
! 1950: * @brief Support function which consumes white spaces in the W3C
! 1951: * sense.
! 1952: *
! 1953: * @param stream The stream where the operation will be performed.
! 1954: *
! 1955: * @return axl_true if more white spaces could be consumed, axl_false
! 1956: * if not.
! 1957: */
! 1958: void axl_stream_consume_white_spaces (axlStream * stream)
! 1959: {
! 1960: /* get how many bytes remains to be read */
! 1961: int remains = stream->stream_size - stream->stream_index;
! 1962:
! 1963: while (axl_true) {
! 1964: /* decrase the number of bytes remaining to be read
! 1965: * and check if it is zero or less than zero to
! 1966: * prebuffer. NOTE: remains could be 1 (remains one
! 1967: * byte) making it possible to consume one byte
! 1968: * more */
! 1969: remains--;
! 1970: if (remains < 0) {
! 1971: /* we fall outside the stream, so a prebuffer
! 1972: * operation is required */
! 1973: if (! axl_stream_prebuffer (stream))
! 1974: return;
! 1975:
! 1976: /* update remains value but this time removing
! 1977: * one unit (the unit to be consumed at the
! 1978: * next sentence) */
! 1979: remains = stream->stream_size - stream->stream_index - 1;
! 1980: }
! 1981:
! 1982: /* check for a white space */
! 1983: if ((stream->stream[stream->stream_index] == ' ') ||
! 1984: (stream->stream[stream->stream_index] == '\n') ||
! 1985: (stream->stream[stream->stream_index] == '\t') ||
! 1986: (stream->stream[stream->stream_index] == '\r')) {
! 1987:
! 1988: /* update internal indexes */
! 1989: stream->stream_index++;
! 1990: stream->global_index++;
! 1991: stream->previous_inspect = 0;
! 1992: }else {
! 1993: /* return */
! 1994: return;
! 1995: }
! 1996:
! 1997: } /* end while */
! 1998:
! 1999: return;
! 2000: }
! 2001:
! 2002:
! 2003:
! 2004: /**
! 2005: * @internal
! 2006: * @brief Allows to compare two strings pointed by
! 2007: *
! 2008: * @param chunk1 The string to be compared.
! 2009: *
! 2010: * @param chunk2 The second string to be compared.
! 2011: *
! 2012: * @param size The amount of bytes to be compared for the two incoming
! 2013: * values.
! 2014: *
! 2015: * @return axl_true if both string are equal, axl_false if not. If
! 2016: * some value provided is NULL or the size to compare is not greater
! 2017: * than 0 the function will return axl_false directly.
! 2018: */
! 2019: axl_bool axl_stream_cmp (const char * chunk1, const char * chunk2, int size)
! 2020: {
! 2021: /* perform some environmental condition checking */
! 2022: if (chunk1 == NULL)
! 2023: return axl_false;
! 2024: if (chunk2 == NULL)
! 2025: return axl_false;
! 2026: if (size < 0)
! 2027: return axl_false;
! 2028:
! 2029: /* report current comparation status */
! 2030: if ((chunk1[0] == chunk2[0])) {
! 2031: if ((size == 1) ||
! 2032: (axl_memcmp (chunk1 + 1, chunk2 + 1, size -1))) {
! 2033: return axl_true;
! 2034: } /* end if */
! 2035: } /* end if */
! 2036:
! 2037: return axl_false;
! 2038: }
! 2039:
! 2040: /**
! 2041: * @brief Provides the same function like axl_stream_cmp but
! 2042: * ignoring the case of the characters (case insensitive manner).
! 2043: *
! 2044: * @param chunk1 The string to be compared.
! 2045: *
! 2046: * @param chunk2 The second string to be compared.
! 2047: *
! 2048: * @param size The amount of bytes to be compared for the two incoming
! 2049: * values.
! 2050: *
! 2051: * @return axl_true if both string are equal, axl_false if not. If
! 2052: * some value provided is NULL or the size to compare is not greater
! 2053: * than 0 the function will return axl_false directly.
! 2054: */
! 2055: axl_bool axl_stream_casecmp (const char * chunk1, const char * chunk2, int size)
! 2056: {
! 2057: /* perform some environmental condition checking */
! 2058: if (chunk1 == NULL)
! 2059: return axl_false;
! 2060: if (chunk2 == NULL)
! 2061: return axl_false;
! 2062: if (size < 0)
! 2063: return axl_false;
! 2064:
! 2065: /* returh if both strings are equal. */
! 2066: #if defined(AXL_OS_WIN32)
! 2067: return _strnicmp (chunk1, chunk2, size) == 0;
! 2068: #else
! 2069: return strncasecmp (chunk1, chunk2, size) == 0;
! 2070: #endif
! 2071: }
! 2072:
! 2073: /**
! 2074: * @internal
! 2075: *
! 2076: * @brief Allows to check if the provided stream could support
! 2077: * checking a chunk of, at least, the provided inspected size.
! 2078: *
! 2079: * @param stream The stream where the inspected operation is being
! 2080: * requested.
! 2081: *
! 2082: * @param inspected_size The size to inspected, that is being
! 2083: * requested to be checked on the given stream.
! 2084: *
! 2085: * @return \ref axl_true if the provided chunk falls out side the
! 2086: * stream boundaries, or axl_false if requested inspected size could
! 2087: * be supported.
! 2088: */
! 2089: axl_bool axl_stream_fall_outside (axlStream * stream, int inspected_size)
! 2090: {
! 2091: /* if the content is inside memory, check it */
! 2092: if (fall_out_side_checking (stream, inspected_size)) {
! 2093: return (! axl_stream_prebuffer (stream));
! 2094: }
! 2095:
! 2096: /* otherwise, axl_false is returned */
! 2097: return axl_false;
! 2098: }
! 2099:
! 2100: /**
! 2101: * @internal
! 2102: *
! 2103: * @brief Allows to check if the given stream have as a next element
! 2104: * the provided chunk.
! 2105: *
! 2106: * @param stream The stream where the operation will be performed.
! 2107: * @param chunk The chunk to check
! 2108: *
! 2109: * @return Returns axl_true if the given stream contains the value requested
! 2110: * or axl_false if not.
! 2111: */
! 2112: axl_bool axl_stream_check (axlStream * stream, char * chunk, int inspected_size)
! 2113: {
! 2114: int iterator;
! 2115:
! 2116: /* call to the internal implementation of axl_memcmp */
! 2117: _memcmp(iterator,chunk,(stream->stream + stream->stream_index), inspected_size);
! 2118:
! 2119: }
! 2120:
! 2121: /**
! 2122: * @brief Allows to get current status of the stream.
! 2123: *
! 2124: * If the is exhausted and have no more data to be read.
! 2125: *
! 2126: * @param stream The stream that is being checked.
! 2127: *
! 2128: * @return axl_true if the stream is exhausted or axl_false if not.
! 2129: */
! 2130: axl_bool axl_stream_remains (axlStream * stream)
! 2131: {
! 2132: axl_return_val_if_fail (stream, axl_false);
! 2133:
! 2134:
! 2135: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "checking for stream status with stream index=%d and stream size=%d",
! 2136: stream->stream_index, stream->stream_size);
! 2137:
! 2138: /* check if the stream is exhausted */
! 2139: if (stream->stream_index >= (stream->stream_size)) {
! 2140:
! 2141: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "prebufferring from remains");
! 2142:
! 2143: /* in the case the stream is exhausted, try to read
! 2144: * more content from the streaming */
! 2145: return axl_stream_prebuffer (stream);
! 2146: }
! 2147: return axl_true;
! 2148: }
! 2149:
! 2150:
! 2151: /* @} */
! 2152:
! 2153: /**
! 2154: * \defgroup axl_string_module Axl String: String functions provided by the Axl Stream module.
! 2155: */
! 2156:
! 2157: /**
! 2158: * \addtogroup axl_string_module
! 2159: * @{
! 2160: */
! 2161:
! 2162: /**
! 2163: *
! 2164: * @brief Allows to trim the provided chunk, removing all white spaces
! 2165: * (returns, white spaces, carry return and tabulars) that comes as
! 2166: * preffix and suffix for the string provided, referenced by chunk.
! 2167: *
! 2168: * The function retuns the reference to the new chunk already
! 2169: * translated. The function doesn't perform any memory allocation. It
! 2170: * uses the memory already used to hold the chunk provided, returning
! 2171: * a pointer for the first item that is not a white space and
! 2172: * nullifing the first item that is a white space behind the chunk.
! 2173: *
! 2174: * This function is particular useful while getting the content
! 2175: *
! 2176: * @param chunk The chunk to trim.
! 2177: *
! 2178: */
! 2179: void axl_stream_trim (char * chunk)
! 2180: {
! 2181: /* call to trim */
! 2182: axl_stream_trim_with_size (chunk, NULL);
! 2183:
! 2184: return;
! 2185: }
! 2186:
! 2187: /**
! 2188: * @brief The function works like \ref axl_stream_trim, but providing
! 2189: * the count of bytes trimmed from the string.
! 2190: *
! 2191: * @param chunk The chunk to trim.
! 2192: *
! 2193: * @param trimmed An optional reference that returns the count of bytes
! 2194: * trimmed by the operation.
! 2195: */
! 2196: void axl_stream_trim_with_size (char * chunk, int * trimmed)
! 2197: {
! 2198: int iterator;
! 2199: int iterator2;
! 2200: int end;
! 2201: int total;
! 2202:
! 2203: /* perform some environment check */
! 2204: axl_return_if_fail (chunk);
! 2205:
! 2206: /* check empty string received */
! 2207: if (strlen (chunk) == 0) {
! 2208: if (trimmed)
! 2209: *trimmed = 0;
! 2210: return;
! 2211: }
! 2212:
! 2213: /* check the amount of white spaces to remove from the
! 2214: * begin */
! 2215: iterator = 0;
! 2216: while (chunk[iterator] != 0) {
! 2217:
! 2218: /* check that the iterator is not pointing to a white
! 2219: * space */
! 2220: if (! axl_stream_is_white_space (chunk + iterator))
! 2221: break;
! 2222:
! 2223: /* update the iterator */
! 2224: iterator++;
! 2225: }
! 2226:
! 2227: /* check for the really basic case where an empty string is found */
! 2228: if (iterator == strlen (chunk)) {
! 2229: /* an empty string, trim it all */
! 2230: chunk [0] = 0;
! 2231: if (trimmed)
! 2232: *trimmed = iterator;
! 2233: return;
! 2234: } /* end if */
! 2235:
! 2236: /* now get the position for the last valid character in the
! 2237: * chunk */
! 2238: total = strlen (chunk) -1;
! 2239: end = total;
! 2240: while (chunk[end] != 0) {
! 2241:
! 2242: /* stop if a white space is found */
! 2243: if (! axl_stream_is_white_space (chunk + end)) {
! 2244: break;
! 2245: }
! 2246:
! 2247: /* update the iterator to eat the next white space */
! 2248: end--;
! 2249: }
! 2250:
! 2251: /* the number of items trimmed */
! 2252: total -= end;
! 2253: total += iterator;
! 2254:
! 2255: /* copy the exact amount of non white spaces items */
! 2256: iterator2 = 0;
! 2257: while (iterator2 < (end - iterator + 1)) {
! 2258: /* copy the content */
! 2259: chunk [iterator2] = chunk [iterator + iterator2];
! 2260:
! 2261: /* update the iterator */
! 2262: iterator2++;
! 2263: }
! 2264: chunk [ end - iterator + 1] = 0;
! 2265:
! 2266: if (trimmed != NULL)
! 2267: *trimmed = total;
! 2268:
! 2269: /* return the result reference */
! 2270: return;
! 2271: }
! 2272:
! 2273: /**
! 2274: * @brief Allows to remote occurences of value from the provided
! 2275: * string (chunk).
! 2276: *
! 2277: * The function do not allocate new memory for the result. All
! 2278: * operations are applied to the string received (chunk).
! 2279: *
! 2280: * The idea behind the functions is to allow removing values from the
! 2281: * string, joining remaining content. For example, removing "-" from
! 2282: * the string "iso-8859-15" yields "iso885915".
! 2283: *
! 2284: * @param chunk The string that holds values to be removed.
! 2285: *
! 2286: * @param value The value to be removed.
! 2287: *
! 2288: * @param first If only the first ocurrence of value must be removed,
! 2289: * otherwise all ocurrences will be removed from the string.
! 2290: */
! 2291: void axl_stream_remove (char * chunk, const char * value, axl_bool first)
! 2292: {
! 2293: int iterator;
! 2294: int iterator2;
! 2295: int length;
! 2296: int v_length;
! 2297:
! 2298: axl_return_if_fail (chunk);
! 2299: axl_return_if_fail (value);
! 2300:
! 2301: /* get lengths */
! 2302: length = strlen (chunk);
! 2303: v_length = strlen (value);
! 2304:
! 2305: /* check for basic cases */
! 2306: if (length == v_length) {
! 2307: /* check if both strings are equal, then nullify */
! 2308: if (axl_cmp (chunk, value))
! 2309: chunk [0] = 0;
! 2310: return;
! 2311: } else if (length < v_length) {
! 2312: /* nothing to remove because parent string is too
! 2313: * small to store the content */
! 2314: return;
! 2315: } /* end if */
! 2316:
! 2317:
! 2318: /* locate the string */
! 2319: iterator = 0;
! 2320: while (iterator < length) {
! 2321: /* check if the string value was found */
! 2322: if (axl_memcmp (chunk + iterator, value, v_length)) {
! 2323: /* string found, move content remaining (if is found) */
! 2324: if ((length - iterator - v_length) > 0) {
! 2325: iterator2 = 0;
! 2326: while (iterator2 < (length - iterator - v_length)) {
! 2327: chunk [iterator + iterator2] = chunk [iterator + iterator2 + v_length];
! 2328: iterator2++;
! 2329: } /* end while */
! 2330: } /* end if */
! 2331:
! 2332: /* update length to the new value */
! 2333: length -= v_length;
! 2334:
! 2335: /* check to terminate for first ocurrence */
! 2336: if (first) {
! 2337: chunk [length] = 0;
! 2338: return;
! 2339: }
! 2340: continue;
! 2341: } /* end if */
! 2342:
! 2343: /* next position */
! 2344: iterator++;
! 2345: } /* end while */
! 2346:
! 2347: /* nullify and terminate */
! 2348: chunk [length] = 0;
! 2349: return;
! 2350: }
! 2351:
! 2352: /**
! 2353: * @brief Allows to copy the given chunk, supposing that is a properly
! 2354: * format C string that ends with a '\\0' value.
! 2355: *
! 2356: * This function allows to perform a copy for the given string. If a
! 2357: * copy limited by a size is required, use \ref axl_stream_strdup_n.
! 2358: *
! 2359: * @param chunk The chunk to copy
! 2360: *
! 2361: * @return A newly allocated string or NULL if fails.
! 2362: */
! 2363: char * axl_stream_strdup (const char * chunk)
! 2364: {
! 2365: char * result;
! 2366: int length;
! 2367:
! 2368: /* return NULL reference if a NULL reference is received */
! 2369: if (chunk == NULL)
! 2370: return NULL;
! 2371:
! 2372: length = strlen (chunk);
! 2373: result = axl_new (char, length + 1);
! 2374:
! 2375: memcpy (result, chunk, length);
! 2376:
! 2377: return result;
! 2378: }
! 2379:
! 2380: /**
! 2381: * @brief Allows to perform a copy for the <b>n</b> first bytes from
! 2382: * the <b>chunk</b> received.
! 2383: *
! 2384: * @param chunk The chunk to copy
! 2385: *
! 2386: * @param n How many bytes to copy from the given chunk.
! 2387: *
! 2388: * @return A newly allocated chunk, copied from the given chunk with a
! 2389: * size of <b>n</b> bytes. The function will check that the
! 2390: * <b>chunk</b> and the <b>n</b> values are not null and non-zero.
! 2391: */
! 2392: char * axl_stream_strdup_n (const char * chunk, int n)
! 2393: {
! 2394: char * result;
! 2395:
! 2396: axl_return_val_if_fail (chunk, NULL);
! 2397: axl_return_val_if_fail (n, NULL);
! 2398:
! 2399: result = axl_new (char, n + 1);
! 2400: memcpy (result, chunk, n);
! 2401:
! 2402: return result;
! 2403: }
! 2404:
! 2405: /**
! 2406: * @internal Allows to calculate the amount of memory required to
! 2407: * store the string that will representing the construction provided
! 2408: * by the printf-like format received and its arguments.
! 2409: *
! 2410: * @param format The printf-like format to be printed.
! 2411: *
! 2412: * @param args The set of arguments that the printf applies to.
! 2413: *
! 2414: * <i><b>NOTE:</b> not all printf specification is supported. Generally, the
! 2415: * following is supported: %s, %d, %f, %g, %ld, %lg and all
! 2416: * combinations that provides precision, number of items inside the
! 2417: * integer part, etc: %6.2f, %+2d, etc. An especial case not supported
! 2418: * is %lld, %llu and %llg.</i>
! 2419: *
! 2420: * @return Return the number of bytes that must be allocated to hold
! 2421: * the string (including the string terminator \0). If the format is
! 2422: * not correct or it is not properly formated according to the value
! 2423: * found at the argument set, the function will return -1.
! 2424: */
! 2425: int axl_stream_vprintf_len (const char * format, va_list args)
! 2426: {
! 2427: #if defined (AXL_OS_WIN32) && ! defined (__GNUC__)
! 2428: # if HAVE_VSCPRINTF
! 2429: if (format == NULL)
! 2430: return 0;
! 2431: return _vscprintf (format, args) + 1;
! 2432: # else
! 2433: char buffer[8192];
! 2434: if (format == NULL)
! 2435: return 0;
! 2436: return _vsnprintf (buffer, 8191, format, args) + 1;
! 2437: # endif
! 2438: #else
! 2439: /* gnu gcc case */
! 2440: if (format == NULL)
! 2441: return 0;
! 2442: return vsnprintf (NULL, 0, format, args) + 1;
! 2443: #endif
! 2444: }
! 2445:
! 2446: /**
! 2447: * @brief Allows to perform a printf operation on the provided buffer
! 2448: * (which must be allocated by the caller, and its size signaled by
! 2449: * buffer_size).
! 2450: *
! 2451: *
! 2452: * @param buffer The already allocated buffer to hold the result.
! 2453: *
! 2454: * @param buffer_size The size of the buffer provided.
! 2455: *
! 2456: * @param real_size Optional reference where the real space required
! 2457: * to hold the content will be placed. In cases where the content is
! 2458: * enough small to hold in the buffer, this value will contain the
! 2459: * same value as returned by the function. In the case the buffer
! 2460: * provide can't hold all the content, the function will return at
! 2461: * maximum (buffer_size - 1) bytes written, that is, all content that
! 2462: * was possible to be included plus a trailing \\0 to terminate the
! 2463: * string, and, if defined <i>real_size</i> variable, it will contain
! 2464: * the space that will be required.
! 2465: *
! 2466: * @param format The printf like format to use to create the content
! 2467: * to be placed at the buffer provided.
! 2468: *
! 2469: * @return The amount of bytes written. The function will return at
! 2470: * maximum buffer_size - 1 bytes written. Use <i>real_size</i>
! 2471: * variable to check if the function was able to write all content (if
! 2472: * real_size == value returned).
! 2473: */
! 2474: int axl_stream_printf_buffer (char * buffer,
! 2475: int buffer_size,
! 2476: int * real_size,
! 2477: const char * format, ...)
! 2478: {
! 2479: va_list args;
! 2480: int result;
! 2481: #if defined(AXL_OS_WIN32)
! 2482: int check_size;
! 2483: #endif
! 2484:
! 2485: /* check foramt and optn */
! 2486: if (format == NULL) {
! 2487: /* clean real size if it was defined */
! 2488: if (real_size)
! 2489: (*real_size) = 0;
! 2490: return 0;
! 2491: }
! 2492: /* open stdargs */
! 2493: va_start (args, format);
! 2494:
! 2495: # if defined (AXL_OS_WIN32)
! 2496: /* because undre windows all its string family of functions
! 2497: * return -1 in the case not enough espace is available, we
! 2498: * have to check first before calling to _vsnprintf */
! 2499: check_size = axl_stream_vprintf_len (format, args);
! 2500:
! 2501: /* call to close to avoid problems with amd64 platforms */
! 2502: va_end (args);
! 2503: va_start (args, format);
! 2504:
! 2505: /* windows case */
! 2506: result = _vsnprintf (buffer, buffer_size, format, args);
! 2507: if (result == -1) {
! 2508: /* nullify last character and update "result" to point
! 2509: * to the amount of data written (buffer - 1). */
! 2510: result = (buffer_size - 1);
! 2511: buffer[result] = 0;
! 2512: } /* end if */
! 2513: #else
! 2514: /* gnu gcc case */
! 2515: result = vsnprintf (buffer, buffer_size, format, args);
! 2516: #endif
! 2517: /* close stdarg */
! 2518: va_end (args);
! 2519:
! 2520: /* report real size required */
! 2521: if (real_size) {
! 2522: #if defined(AXL_OS_WIN32)
! 2523: (*real_size) = check_size - 1;
! 2524: #else
! 2525: (*real_size) = result;
! 2526: #endif
! 2527: } /* end if */
! 2528:
! 2529: /* limit result */
! 2530: if (result > (buffer_size - 1))
! 2531: result = (buffer_size - 1);
! 2532:
! 2533: return result;
! 2534: }
! 2535:
! 2536: /**
! 2537: * @internal Function that allows to get how many bytes will be
! 2538: * required to hold the format and the arguments provided.
! 2539: *
! 2540: * @param format The printf-like format followed by the rest of
! 2541: * arguments.
! 2542: *
! 2543: * @return Return the number of bytes that must be allocated to hold
! 2544: * the string (including the string terminator \0). If the format is
! 2545: * not correct or it is not properly formated according to the value
! 2546: * found at the argument set, the function will return -1.
! 2547: */
! 2548: int axl_stream_printf_len (const char * format, ...)
! 2549: {
! 2550: int result;
! 2551: va_list args;
! 2552:
! 2553: va_start (args, format);
! 2554:
! 2555: /* get the result */
! 2556: result = axl_stream_vprintf_len (format, args);
! 2557:
! 2558: va_end (args);
! 2559:
! 2560: return result;
! 2561: }
! 2562:
! 2563:
! 2564: /**
! 2565: * @brief Allows to produce an newly allocated string produced by the
! 2566: * chunk received plus arguments, using the printf-like format.
! 2567: *
! 2568: * @param chunk The chunk to copy.
! 2569: *
! 2570: * @return A newly allocated chunk.
! 2571: */
! 2572: char * axl_stream_strdup_printf (const char * chunk, ...)
! 2573: {
! 2574: char * result = NULL;
! 2575: va_list args;
! 2576:
! 2577: axl_return_val_if_fail (chunk, NULL);
! 2578:
! 2579: /* open std args */
! 2580: va_start (args, chunk);
! 2581:
! 2582: /* get the string */
! 2583: result = axl_stream_strdup_printfv (chunk, args);
! 2584:
! 2585: /* close std args */
! 2586: va_end (args);
! 2587:
! 2588: return result;
! 2589: }
! 2590:
! 2591: /**
! 2592: * @brief DEPRECATED: Allows to produce an string representing the
! 2593: * message hold by chunk with the parameters provided.
! 2594: *
! 2595: * @param chunk The message chunk to print.
! 2596: * @param args The arguments for the chunk.
! 2597: *
! 2598: * @return A newly allocated string.
! 2599: *
! 2600: * IMPLEMENTATION NOTE: This function have a fundamental bug due to
! 2601: * the design of va_list arguments under amd64 platforms. In short, a
! 2602: * function receiving a va_list argument can't use it twice. In you
! 2603: * are running amd64, check your axl_config.h did find
! 2604: * AXL_HAVE_VASPRINTF.
! 2605: */
! 2606: char * axl_stream_strdup_printfv (const char * chunk, va_list args)
! 2607: {
! 2608: /** IMPLEMENTATION NOTE: place update exarg_strdup_printfv
! 2609: * code in the case this code is updated **/
! 2610:
! 2611: #ifndef AXL_HAVE_VASPRINTF
! 2612: int size;
! 2613: #endif
! 2614: char * result = NULL;
! 2615: int new_size = -1;
! 2616:
! 2617: axl_return_val_if_fail (chunk, NULL);
! 2618:
! 2619: #ifdef AXL_HAVE_VASPRINTF
! 2620: /* do the operation using the GNU extension */
! 2621: new_size = vasprintf (&result, chunk, args);
! 2622: #else
! 2623: /* get the amount of memory to be allocated */
! 2624: size = axl_stream_vprintf_len (chunk, args);
! 2625:
! 2626: /* check result */
! 2627: if (size == -1) {
! 2628: __axl_log (LOG_DOMAIN, AXL_LEVEL_CRITICAL, "unable to calculate the amount of memory for the strdup_printf operation");
! 2629: return NULL;
! 2630: } /* end if */
! 2631:
! 2632: /* allocate memory */
! 2633: result = axl_new (char, size + 2);
! 2634:
! 2635: /* copy current size */
! 2636: # if defined(AXL_OS_WIN32) && ! defined (__GNUC__)
! 2637: new_size = _vsnprintf_s (result, size + 1, size, chunk, args);
! 2638: # else
! 2639: new_size = vsnprintf (result, size + 1, chunk, args);
! 2640: # endif
! 2641: #endif
! 2642: /* return the result */
! 2643: return result;
! 2644: }
! 2645:
! 2646: /**
! 2647: * @brief Allows to create a newly allocated chunk, providing its
! 2648: * values as a printf call function, but also returning the chunk
! 2649: * size.
! 2650: *
! 2651: * This function works like \ref axl_stream_strdup_printf, but
! 2652: * providing an integer reference where the result chunk length will
! 2653: * be returned.
! 2654: *
! 2655: * @param chunk The printf chunk format to allocate.
! 2656: *
! 2657: * @param chunk_size A reference to fill the chunk lenght.
! 2658: *
! 2659: * @return A newly allocated chunk.
! 2660: */
! 2661: char * axl_stream_strdup_printf_len (const char * chunk, int * chunk_size, ...)
! 2662: {
! 2663: #ifndef AXL_HAVE_VASPRINTF
! 2664: int size;
! 2665: #endif
! 2666: int new_size;
! 2667: char * result;
! 2668: va_list args;
! 2669:
! 2670: axl_return_val_if_fail (chunk, NULL);
! 2671:
! 2672: /* open std args */
! 2673: va_start (args, chunk_size);
! 2674:
! 2675: #ifdef AXL_HAVE_VASPRINTF
! 2676: /* do the operation using the GNU extension */
! 2677: new_size = vasprintf (&result, chunk, args);
! 2678:
! 2679: /* reopen to avoid amd64 bug */
! 2680: va_end (args);
! 2681: va_start (args, chunk_size);
! 2682: #else
! 2683: /* get the amount of memory to be allocated */
! 2684: size = axl_stream_vprintf_len (chunk, args);
! 2685:
! 2686: /* reopen to avoid amd64 bug */
! 2687: va_end (args);
! 2688: va_start (args, chunk_size);
! 2689:
! 2690: /* check result */
! 2691: if (size == -1) {
! 2692: __axl_log (LOG_DOMAIN, AXL_LEVEL_CRITICAL, "unable to calculate the amount of memory for the strdup_printf operation");
! 2693: return NULL;
! 2694: } /* end if */
! 2695:
! 2696: /* allocate memory */
! 2697: result = axl_new (char, size + 2);
! 2698:
! 2699: /* copy current size */
! 2700: #if defined(AXL_OS_WIN32) && ! defined (__GNUC__)
! 2701: new_size = _vsnprintf_s (result, size + 1, size, chunk, args);
! 2702: #else
! 2703: new_size = vsnprintf (result, size + 1, chunk, args);
! 2704: #endif
! 2705: #endif
! 2706:
! 2707: /* close std args */
! 2708: va_end (args);
! 2709:
! 2710: /* fill the chunk size result */
! 2711: if (chunk_size != NULL)
! 2712: *chunk_size = new_size;
! 2713:
! 2714: return result;
! 2715: }
! 2716:
! 2717: /**
! 2718: * @brief Allows to split the provided chunk, into several pieces that
! 2719: * are separated by the separator (or separators) provided.
! 2720: *
! 2721: * The function will try to split the chunk provide using the
! 2722: * separator provided, and optionally, all separators provided.
! 2723: *
! 2724: * Here is an example:
! 2725: * \code
! 2726: * char ** result;
! 2727: *
! 2728: * // split the provided value using the ':', ';' and ',' as separators.
! 2729: * result = axl_stream_split (value, 3, ":", ";", ",");
! 2730: * \endcode
! 2731: *
! 2732: * The value returned must be deallocated using \ref axl_stream_freev.
! 2733: *
! 2734: * @param chunk The chunk to split.
! 2735: *
! 2736: * @param separator_num The number os separators to be used while
! 2737: * spliting the chunk.
! 2738: *
! 2739: * @return A newly allocated string, that must be deallocated by using
! 2740: * \ref axl_stream_freev. The function will return a NULL if the chunk
! 2741: * or the separators provided are NULL.
! 2742: *
! 2743: * NOTE: See also \ref axl_split.
! 2744: */
! 2745: char ** axl_stream_split (const char * chunk, int separator_num, ...)
! 2746: {
! 2747: va_list args;
! 2748: char ** separators;
! 2749: char ** result;
! 2750: int iterator;
! 2751: int index;
! 2752: int previous_index;
! 2753: int count = 0;
! 2754: int length = 0;
! 2755:
! 2756: /* check received values */
! 2757: axl_return_val_if_fail (chunk, NULL);
! 2758: axl_return_val_if_fail (separator_num > 0, NULL);
! 2759:
! 2760: separators = axl_new (char *, separator_num + 1);
! 2761: iterator = 0;
! 2762: va_start (args, separator_num);
! 2763:
! 2764: /* get all separators to be used */
! 2765: while (iterator < separator_num) {
! 2766: separators[iterator] = va_arg (args, char *);
! 2767: iterator++;
! 2768: } /* end if */
! 2769:
! 2770: va_end (args);
! 2771:
! 2772: /* now, count the number of strings that we will get by
! 2773: * separating the string into several pieces */
! 2774: index = 0;
! 2775: while (*(chunk + index) != 0) {
! 2776:
! 2777: /* reset the iterator */
! 2778: iterator = 0;
! 2779: while (iterator < separator_num) {
! 2780:
! 2781: /* compare the current index with the current
! 2782: * separator */
! 2783: length = strlen (separators[iterator]);
! 2784: if (axl_memcmp (chunk + index, separators[iterator], length)) {
! 2785:
! 2786: /* update items found */
! 2787: count++;
! 2788:
! 2789: /* update index to skip the item found */
! 2790: index += length - 1; /* make the last index to be captured the the -1 */
! 2791:
! 2792: /* break the loop */
! 2793: break;
! 2794: }
! 2795: iterator++;
! 2796: }
! 2797:
! 2798: /* update the index to the next item */
! 2799: index++;
! 2800: } /* end if */
! 2801:
! 2802: /* create the result that will hold items separated */
! 2803: result = axl_new (char *, count + 2);
! 2804:
! 2805: /* now copy items found */
! 2806: count = 0;
! 2807: index = 0;
! 2808:
! 2809: /* remember previous_index */
! 2810: previous_index = index;
! 2811: while (*(chunk + index) != 0) {
! 2812:
! 2813: /* reset the iterator */
! 2814: iterator = 0;
! 2815: while (iterator < separator_num) {
! 2816:
! 2817: /* compare the current index with the current
! 2818: * separator */
! 2819: length = strlen (separators[iterator]);
! 2820: if (axl_memcmp (chunk + index, separators[iterator], length)) {
! 2821:
! 2822: /* copy the chunk found */
! 2823: result[count] = axl_new (char, index - previous_index + 1);
! 2824: memcpy (result[count], chunk + previous_index, index - previous_index);
! 2825:
! 2826: /* axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "item found (last) '%s' (index=%d != previous=%d", result[count], index, previous_index); */
! 2827:
! 2828: /* update items found */
! 2829: count++;
! 2830:
! 2831: /* update index to skip the item found */
! 2832: if (*(chunk + index + length) == 0) {
! 2833: /* in the case no more elements to read will be found */
! 2834: /* put an empty space at the end */
! 2835: result [count] = axl_new (char, 1);
! 2836:
! 2837: axl_free (separators);
! 2838: return result;
! 2839: }
! 2840:
! 2841: /* remember previous_index */
! 2842: index += length;
! 2843: previous_index = index;
! 2844: index--; /* make the last index to be captured the the -1 */
! 2845: break;
! 2846: }
! 2847: iterator++;
! 2848: }
! 2849:
! 2850: /* update the index to the next item */
! 2851: index++;
! 2852: }
! 2853:
! 2854: /* check for a last chunk */
! 2855: if (index != previous_index) {
! 2856: /* copy the chunk found */
! 2857: result[count] = axl_new (char, index - previous_index + 1);
! 2858: memcpy (result[count], chunk + previous_index, index - previous_index);
! 2859:
! 2860: /* axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "item found (last) '%s' (index=%d != previous=%d", result[count], index, previous_index); */
! 2861: }
! 2862:
! 2863:
! 2864: /* release memory */
! 2865: axl_free (separators);
! 2866:
! 2867: return result;
! 2868: }
! 2869:
! 2870: /**
! 2871: * @brief Allows to clean an split created by \ref axl_stream_split by
! 2872: * removing all items found to be empty strings.
! 2873: *
! 2874: * @param split The split to be updated by removing all empty string
! 2875: * items.
! 2876: *
! 2877: */
! 2878: void axl_stream_clean_split (char ** split)
! 2879: {
! 2880: int iterator;
! 2881: int iterator2;
! 2882: int iterator3;
! 2883:
! 2884: /* check input */
! 2885: axl_return_if_fail (split);
! 2886:
! 2887: /* remove empty strings */
! 2888: iterator = 0;
! 2889: while (split[iterator]) {
! 2890: if (strlen (split[iterator]) == 0) {
! 2891:
! 2892: /* clear position joint */
! 2893: axl_free (split[iterator]);
! 2894: split[iterator] = NULL;
! 2895:
! 2896: /* move strings */
! 2897: iterator3 = 0;
! 2898: iterator2 = iterator + 1;
! 2899: while (split[iterator2 + iterator3]) {
! 2900: /* move reference */
! 2901: split[iterator + iterator3] = split[iterator2 + iterator3];
! 2902:
! 2903: /* nullify */
! 2904: split[iterator2 + iterator3] = NULL;
! 2905:
! 2906: /* next position */
! 2907: iterator3++;
! 2908: } /* end while */
! 2909: continue;
! 2910: } /* end if */
! 2911:
! 2912: /* next iterator */
! 2913: iterator++;
! 2914: } /* end while */
! 2915:
! 2916: return;
! 2917: }
! 2918:
! 2919: /**
! 2920: * @brief Allows to implement the oposite operation of \ref
! 2921: * axl_stream_split, by joing all strings provided inside the array
! 2922: * (strings), using as separator the value provided.
! 2923: *
! 2924: * @param strings The set of strings to be joined.
! 2925: *
! 2926: * @param separator The separator to be used to join all strings
! 2927: * provided.
! 2928: *
! 2929: *
! 2930: * @return A newly allocated reference, that must be release using
! 2931: * \ref axl_free.
! 2932: *
! 2933: * NOTE: See also \ref axl_join.
! 2934: */
! 2935: char * axl_stream_join (char ** strings,
! 2936: const char * separator)
! 2937: {
! 2938: int length;
! 2939: int sep_length;
! 2940: int iterator;
! 2941: char * result;
! 2942: axl_bool next_sep;
! 2943:
! 2944: axl_return_val_if_fail (strings && strings[0], NULL);
! 2945: axl_return_val_if_fail (separator, NULL);
! 2946:
! 2947: /* get the amount of data to be allocated */
! 2948: length = 0;
! 2949: iterator = 0;
! 2950:
! 2951: /* for each value to be joined */
! 2952: while (strings [iterator]) {
! 2953: /* count the number of bytes for each string */
! 2954: length += strlen (strings[iterator]);
! 2955:
! 2956: /* next iterator */
! 2957: iterator++;
! 2958: } /* end while */
! 2959:
! 2960: /* check for the basic case */
! 2961: if (iterator == 1) {
! 2962: /* only one piece is contained in the set of strings
! 2963: * provided, so nothing can be joined */
! 2964: return axl_strdup (strings[0]);
! 2965: }
! 2966:
! 2967: /* add to the length the number of separatos to be added
! 2968: * (wihtout 1) and add a traling byte to terminate the
! 2969: * string */
! 2970: sep_length = strlen (separator);
! 2971: length += (sep_length * (iterator - 1)) + 1;
! 2972: result = axl_new (char, length);
! 2973:
! 2974: iterator = 0;
! 2975: next_sep = axl_false;
! 2976: length = 0;
! 2977:
! 2978: while (strings [iterator]) {
! 2979:
! 2980: /* copy the content */
! 2981: if (next_sep) {
! 2982: memcpy (result + length, separator, sep_length);
! 2983:
! 2984: /* update the length */
! 2985: length += sep_length;
! 2986: } else {
! 2987: memcpy (result + length, strings[iterator], strlen (strings[iterator]));
! 2988:
! 2989: /* update the length */
! 2990: length += strlen (strings[iterator]);
! 2991: } /* end if */
! 2992:
! 2993: /* check if next is separator */
! 2994: next_sep = ! next_sep;
! 2995:
! 2996: /* update the iterator only if next value to be
! 2997: * handled is a separator */
! 2998: if (next_sep)
! 2999: iterator++;
! 3000: } /* end while */
! 3001:
! 3002: /* return string created */
! 3003: return result;
! 3004: }
! 3005:
! 3006: /**
! 3007: * @brief Allows to concatenate the two given strings into a single
! 3008: * one.
! 3009: *
! 3010: * The function will concatenate both string into a newly allocated
! 3011: * string that is the result of taking chunk1 followed by chunk2.
! 3012: *
! 3013: * If the function receive a NULL value for one of the string
! 3014: * received, the result from this function will be the other
! 3015: * string. This is done to support a common basic case where the
! 3016: * string provided for one of the arguments is the one being used two
! 3017: * hold an iterative result. This variable usually is NULL.
! 3018: *
! 3019: * Once the string returned is no longer needed, \ref axl_free must be
! 3020: * used to deallocate the result.
! 3021: *
! 3022: * The function will use the strlen function to calculate current
! 3023: * chunk sizes to provide the result.
! 3024: *
! 3025: *
! 3026: * @param chunk1 The first chunk to be placed on the result.
! 3027: *
! 3028: * @param chunk2 The second chunk to be placed on the result.
! 3029: *
! 3030: * @return A newly allocated string, containing both strings, or NULL
! 3031: * if fails. The only way for this function to fail is to provide two
! 3032: * NULL references as incoming strings.
! 3033: *
! 3034: * NOTE: See also \ref axl_concat.
! 3035: */
! 3036: char * axl_stream_concat (const char * chunk1, const char * chunk2)
! 3037: {
! 3038: char * result;
! 3039: int len1;
! 3040: int len2;
! 3041:
! 3042: axl_return_val_if_fail ((chunk2 != NULL) || (chunk1 != NULL), NULL);
! 3043:
! 3044: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "concat called..");
! 3045:
! 3046: if (chunk1 == NULL) {
! 3047:
! 3048: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "concat called.., returning %s", chunk2);
! 3049:
! 3050: /* return the result */
! 3051: return axl_strdup (chunk2);
! 3052: }
! 3053:
! 3054: if (chunk2 == NULL) {
! 3055:
! 3056: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "concat called.., returning %s", chunk1);
! 3057:
! 3058: /* return the result */
! 3059: return axl_strdup (chunk1);
! 3060: }
! 3061:
! 3062: /* return the concatenation */
! 3063: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "concat called.., returning %s%s", chunk1, chunk2);
! 3064:
! 3065: /* alloc enough memory to hold both strings */
! 3066: len1 = strlen (chunk1);
! 3067: len2 = strlen (chunk2);
! 3068: result = axl_new (char, len1 + len2 + 1);
! 3069:
! 3070: /* copy the content */
! 3071: memcpy (result, chunk1, len1);
! 3072: memcpy (result + len1, chunk2, len2);
! 3073:
! 3074: /* return the string created */
! 3075: return result;
! 3076:
! 3077:
! 3078: }
! 3079:
! 3080:
! 3081: /**
! 3082: * @brief Returns current number of items inside the chunks reference
! 3083: * provided.
! 3084: *
! 3085: * @param chunks The chunks reference, which contains a list of
! 3086: * chunks.
! 3087: *
! 3088: * @return The number of chunks that the reference has or -1 if it
! 3089: * fails.
! 3090: */
! 3091: int axl_stream_strv_num (char ** chunks)
! 3092: {
! 3093: int iterator = 0;
! 3094:
! 3095: axl_return_val_if_fail (chunks, -1);
! 3096: /* release memory used by all elements inside the chunk */
! 3097: while (chunks[iterator] != 0) {
! 3098: iterator++;
! 3099: }
! 3100:
! 3101: /* return current number of chunks */
! 3102: return iterator;
! 3103:
! 3104: }
! 3105:
! 3106: /**
! 3107: * @brief Allows to release memory used by elements returned by \ref
! 3108: * axl_stream_split and other function that return a pointer to a char **.
! 3109: *
! 3110: * @param chunks The chunk to release.
! 3111: */
! 3112: void axl_stream_freev (char ** chunks)
! 3113: {
! 3114: int iterator = 0;
! 3115:
! 3116: axl_return_if_fail (chunks);
! 3117:
! 3118: /* release memory used by all elements inside the chunk */
! 3119: while (chunks[iterator] != 0) {
! 3120: axl_free (chunks[iterator]);
! 3121: iterator++;
! 3122: }
! 3123:
! 3124: /* now release the chunk inside */
! 3125: axl_free (chunks);
! 3126:
! 3127: /* nothing more to do */
! 3128: return;
! 3129: }
! 3130:
! 3131: /**
! 3132: * @internal
! 3133: *
! 3134: * @brief Internal function to support \ref axl_stream_to_upper and
! 3135: * \ref axl_stream_to_lower
! 3136: *
! 3137: * @param chunk The chunk to modify
! 3138: * @param desp Bits to increase.
! 3139: */
! 3140: void __axl_stream_common_to (char * chunk, axl_bool to_upper)
! 3141: {
! 3142: int iterator = 0;
! 3143:
! 3144: axl_return_if_fail (chunk);
! 3145:
! 3146: while (chunk[iterator] != 0) {
! 3147: /* change first ascii level */
! 3148: if (to_upper)
! 3149: chunk[iterator] = toupper (chunk[iterator]);
! 3150: else
! 3151: chunk[iterator] = tolower (chunk[iterator]);
! 3152:
! 3153: /* update iterators */
! 3154: iterator++;
! 3155: }
! 3156:
! 3157: return;
! 3158: }
! 3159:
! 3160: /**
! 3161: * @brief Makes the provided string to be converted to upper case
! 3162: * letters.
! 3163: *
! 3164: * The function will modify the address provided. If you want to get a
! 3165: * upper case copy for a particular string, copy it first, by using
! 3166: * \ref axl_strdup, and then use this function.
! 3167: *
! 3168: * The function, for convenience, will also return the string
! 3169: * reference received, already modified. This could be used while
! 3170: * using this function to convert parameters that are expected by
! 3171: * other functions.
! 3172: *
! 3173: * @param chunk The chunk to upper case.
! 3174: */
! 3175: char * axl_stream_to_upper (char * chunk)
! 3176: {
! 3177: __axl_stream_common_to (chunk, axl_true);
! 3178: return chunk;
! 3179: }
! 3180:
! 3181: /**
! 3182: * @brief Allows to convert the provided string into lower cases
! 3183: * letter.
! 3184: *
! 3185: * The function, for convenience, will also return the string
! 3186: * reference received, already modified. This could be used while
! 3187: * using this function to convert parameters that are expected by
! 3188: * other functions.
! 3189: *
! 3190: * @param chunk The chunk to lower case.
! 3191: */
! 3192: char * axl_stream_to_lower (char * chunk)
! 3193: {
! 3194: __axl_stream_common_to (chunk, axl_false);
! 3195: return chunk;
! 3196: }
! 3197:
! 3198: /**
! 3199: * @brief Allows to perform a to upper operation, like \ref
! 3200: * axl_stream_to_upper, but returning an new allocated reference.
! 3201: *
! 3202: * @param chunk The string reference to upper.
! 3203: *
! 3204: * @return A new reference allocated containing the result or NULL if
! 3205: * it fails.
! 3206: */
! 3207: char * axl_stream_to_upper_copy (const char * chunk)
! 3208: {
! 3209: char * result;
! 3210:
! 3211: /* perform some environmental checks */
! 3212: axl_return_val_if_fail (chunk, NULL);
! 3213:
! 3214: /* make a copy */
! 3215: result = axl_strdup (chunk);
! 3216:
! 3217: /* upper it */
! 3218: __axl_stream_common_to (result, axl_true);
! 3219:
! 3220: /* return the result */
! 3221: return result;
! 3222: }
! 3223:
! 3224:
! 3225: /**
! 3226: * @brief Allows to perform a to lower operation, like \ref
! 3227: * axl_stream_to_upper, but returning an new allocated reference.
! 3228: *
! 3229: * @param chunk The string reference to lower.
! 3230: *
! 3231: * @return A new reference allocated containing the result or NULL if
! 3232: * it fails.
! 3233: */
! 3234: char * axl_stream_to_lower_copy (const char * chunk)
! 3235: {
! 3236: char * result;
! 3237:
! 3238: /* perform some environmental checks */
! 3239: axl_return_val_if_fail (chunk, NULL);
! 3240:
! 3241: /* make a copy */
! 3242: result = axl_strdup (chunk);
! 3243:
! 3244: /* lower it */
! 3245: __axl_stream_common_to (result, axl_false);
! 3246:
! 3247: /* return the result */
! 3248: return result;
! 3249: }
! 3250:
! 3251: /**
! 3252: * @brief Allows to compare two strings provided, s1 and s1 to be
! 3253: * equal.
! 3254: *
! 3255: * In the case both are equal, \ref axl_true is returned. Otherwise \ref
! 3256: * axl_false. The function compares that both are equal not only by making
! 3257: * the first to be contained inside the second string. The check also
! 3258: * ensures that "test" isn't equal to "test1".
! 3259: *
! 3260: * @param string First string to check.
! 3261: *
! 3262: * @param string2 Second string to check.
! 3263: *
! 3264: * @return \ref axl_true if both string are equal, otherwise \ref axl_false is
! 3265: * returned.
! 3266: */
! 3267: axl_bool axl_cmp (const char * string, const char * string2)
! 3268: {
! 3269: int iterator = 0;
! 3270:
! 3271: if (string == NULL)
! 3272: return axl_false;
! 3273: if (string2 == NULL)
! 3274: return axl_false;
! 3275:
! 3276: /* for each item inside the iterator */
! 3277: while (string [iterator] != 0 && string2 [iterator] != 0) {
! 3278:
! 3279: /* check the content */
! 3280: if (string [iterator] != string2 [iterator])
! 3281: return axl_false;
! 3282:
! 3283: /* update the iterator */
! 3284: iterator++;
! 3285:
! 3286: } /* end while */
! 3287:
! 3288: /* check that both string ends at the same point */
! 3289: if (string [iterator] != 0 ||
! 3290: string2 [iterator] != 0)
! 3291: return axl_false;
! 3292:
! 3293: return axl_true;
! 3294: }
! 3295:
! 3296: axl_bool axl_casecmp (const char * string, const char * string2)
! 3297: {
! 3298: int length;
! 3299:
! 3300: if (string == NULL)
! 3301: return axl_false;
! 3302: if (string2 == NULL)
! 3303: return axl_false;
! 3304:
! 3305: /* get length associated to first string */
! 3306: length = strlen (string);
! 3307: if (length != strlen (string2))
! 3308: return axl_false;
! 3309:
! 3310: /* now check both lengths */
! 3311: return axl_stream_casecmp (string, string2, length);
! 3312:
! 3313: }
! 3314:
! 3315:
! 3316: /**
! 3317: * @brief Allows to check if both strings provided are equal on its
! 3318: * initial size bytes.
! 3319: *
! 3320: * This function is more efficient than common memcmp because it
! 3321: * doesn't perform the additional work to figure out which are the
! 3322: * bytes that differ both strings.
! 3323: *
! 3324: * @param string The string to check.
! 3325: *
! 3326: * @param string2 The second string to check.
! 3327: *
! 3328: * @param size The size to check for both strings to be equal.
! 3329: *
! 3330: * @return \ref axl_true if the both strings are equal for its initial
! 3331: * size bytes or \ref axl_false if not.
! 3332: */
! 3333: axl_bool axl_memcmp (const char * string, const char * string2, int size)
! 3334: {
! 3335: int iterator = 0;
! 3336:
! 3337: _memcmp(iterator,string,string2,size);
! 3338: }
! 3339:
! 3340: /**
! 3341: *
! 3342: * @brief Perform a memory copy from the string provided.
! 3343: *
! 3344: * @param string The string to copy.
! 3345: *
! 3346: * @return A newly allocated value or NULL if it fails. The value
! 3347: * returned, must be deallocated using \ref axl_free.
! 3348: */
! 3349: char * axl_strdup (const char * string)
! 3350: {
! 3351: return (string != NULL) ? (char *) axl_stream_strdup ((char *) string) : NULL;
! 3352: }
! 3353:
! 3354: /**
! 3355: * @internal Function that handles decoding operations when decode
! 3356: * functions are defined.
! 3357: *
! 3358: * @param stream The stream where the decode operation will be
! 3359: * performed.
! 3360: *
! 3361: * @param error Optional \ref axlError reference where errors will be
! 3362: * reported.
! 3363: *
! 3364: * @return axl_true if the operation was completed.
! 3365: */
! 3366: axl_bool axl_stream_decode (axlStream * stream,
! 3367: char * output,
! 3368: int output_max_size,
! 3369: int * output_decoded,
! 3370: int * op_result,
! 3371: axlError ** error)
! 3372: {
! 3373:
! 3374: int result;
! 3375: int size;
! 3376:
! 3377: /* clear op_result if defined */
! 3378: if (op_result)
! 3379: *op_result = 0;
! 3380:
! 3381: /* decode content from the stream directly */
! 3382: result = stream->decode_f (
! 3383: /* source */
! 3384: stream->decode_temp,
! 3385: /* source size */
! 3386: stream->decode_temp_last,
! 3387: /* source encoding: encode used by the source
! 3388: * content provided */
! 3389: stream->source_encoding,
! 3390: /* output of content decoded and its size */
! 3391: output,
! 3392: /* output max size */
! 3393: output_max_size,
! 3394: /* output decoded */
! 3395: output_decoded,
! 3396: /* source remaining */
! 3397: &(stream->decode_temp_remain),
! 3398: /* user defined data */
! 3399: stream->decode_f_data);
! 3400:
! 3401: /* set op result if defined */
! 3402: if (op_result)
! 3403: *op_result = result;
! 3404:
! 3405: /* check result */
! 3406: if (result == 0) {
! 3407: __axl_log (LOG_DOMAIN, AXL_LEVEL_CRITICAL, "after decode operation result=%d, output_decoded (new buffer size)=%d (from %d original bytes)",
! 3408: result, output_decoded ? *output_decoded : 0, stream->decode_temp_last);
! 3409: axl_error_new (-1, "found internal failure at decode operation, unable to complete entity parsing",
! 3410: stream, error);
! 3411: return axl_false;
! 3412: } /* end if */
! 3413:
! 3414: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "after decode operation result=%d, output_decoded (new buffer size)=%d",
! 3415: result, output_decoded ? *output_decoded : 0);
! 3416:
! 3417: /* update axl stream internal state */
! 3418: if (result == 1) {
! 3419: /* then the conversión was complete a no data
! 3420: * is pending the the temporal decode
! 3421: * buffer */
! 3422: stream->decode_temp_index = 0;
! 3423: stream->decode_temp_last = 0;
! 3424: } else if (result == 2) {
! 3425: /* not enough space was found at the destination
! 3426: * buffer, pack content at the decode buffer at the
! 3427: * next operation */
! 3428: size = stream->decode_temp_last - stream->decode_temp_remain;
! 3429: if (size <= 0) {
! 3430: __axl_log (LOG_DOMAIN, AXL_LEVEL_CRITICAL,
! 3431: "found decode function return 2 (signaling pending data to be decoded) but last - remain yields to %d",
! 3432: size);
! 3433: axl_error_new (-1, "found decode function return 2 (signaling pending data to be decoded) but last - remain yields to 0 or less", NULL, error);
! 3434: return axl_false;
! 3435: } /* end if */
! 3436:
! 3437: /* moving data */
! 3438: while (stream->decode_temp_index < size) {
! 3439: stream->decode_temp[stream->decode_temp_index] = stream->decode_temp[stream->decode_temp_remain + stream->decode_temp_index];
! 3440: stream->decode_temp_index++;
! 3441: } /* end while */
! 3442:
! 3443: /* now reset */
! 3444: stream->decode_temp_index = 0;
! 3445: stream->decode_temp_last = size;
! 3446:
! 3447: /* reset to 1 since we have moved content to
! 3448: * the begin of the buffer */
! 3449: result = 1;
! 3450: } /* end if */
! 3451:
! 3452: return (result == 1);
! 3453: }
! 3454:
! 3455: /**
! 3456: * @internal Function used by the axl stream module to call to check
! 3457: * function defined.
! 3458: *
! 3459: * @return axl_true if the check was fine, otherwise axl_false is returned.
! 3460: */
! 3461: axl_bool axl_stream_content_check (axlStream * stream, const char * content, int content_length, axlError ** error)
! 3462: {
! 3463: if (stream == NULL || content == NULL) {
! 3464: __axl_log (LOG_DOMAIN, AXL_LEVEL_CRITICAL, "content check function failed because null reference was received.");
! 3465: axl_error_new (-1, "content check function failed because null reference was received.", stream, error);
! 3466: return axl_false;
! 3467: } /* end if */
! 3468:
! 3469: /* return appropiate value */
! 3470: if (stream->check_f (content, content_length, stream->source_encoding, stream->check_f_data, error) == 1)
! 3471: return axl_true;
! 3472:
! 3473: __axl_log (LOG_DOMAIN, AXL_LEVEL_CRITICAL, "content check function have failed");
! 3474:
! 3475: /* check if error reference was defined */
! 3476: return axl_false;
! 3477: }
! 3478:
! 3479:
! 3480: /**
! 3481: * @internal Allows to configure a decode functions to be used to
! 3482: * translate content read into utf-8.
! 3483: *
! 3484: * @param stream The stream to be configured.
! 3485: *
! 3486: * @param source_encoding Original source encode.
! 3487: *
! 3488: * @param decode_f The function to be called to translate/check
! 3489: * content read into utf-8. If a null value is provided the decode
! 3490: * function is removed.
! 3491: *
! 3492: * @param error The reference where errors will be reported.
! 3493: *
! 3494: * @return axl_true if the function setup decode handler properly
! 3495: * otherwise axl_false is returned.
! 3496: */
! 3497: axl_bool axl_stream_setup_decode (axlStream * stream,
! 3498: const char * source_encoding,
! 3499: axlStreamDecode decode_f,
! 3500: axlPointer user_data,
! 3501: axlError ** error)
! 3502: {
! 3503: axl_return_val_if_fail (stream, axl_false);
! 3504:
! 3505: /* do not check if the decode_f function is NULL (it's a valid
! 3506: * case) */
! 3507: stream->decode_f = decode_f;
! 3508: stream->decode_f_data = user_data;
! 3509:
! 3510: /* store source encoding */
! 3511: if (source_encoding != NULL)
! 3512: stream->source_encoding = axl_strdup (source_encoding);
! 3513:
! 3514: /* call to check and decode if required bufferede content */
! 3515: if (stream->decode_f) {
! 3516: /* init decode buffer */
! 3517: stream->decode_temp_size = (stream->buffer_size * 2) + 1;
! 3518: stream->decode_temp = axl_new (char, stream->decode_temp_size);
! 3519:
! 3520: /* move content into decode temporal buffer */
! 3521: memcpy (stream->decode_temp,
! 3522: stream->stream + stream->stream_index,
! 3523: stream->stream_size - stream->stream_index);
! 3524: stream->decode_temp_index = 0;
! 3525: stream->decode_temp_last = stream->stream_size - stream->stream_index;
! 3526: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "procesing %d bytes from decode buffer (total size: %d, current index: 0)",
! 3527: stream->decode_temp_last, stream->decode_temp_size);
! 3528:
! 3529: /* call to decode content */
! 3530: if (! axl_stream_decode (stream,
! 3531: /* output */
! 3532: (stream->stream + stream->stream_index),
! 3533: /* output max size */
! 3534: stream->buffer_size - stream->stream_index,
! 3535: /* output decoded */
! 3536: &(stream->stream_size),
! 3537: /* do not define op result */
! 3538: NULL,
! 3539: error))
! 3540: return axl_false;
! 3541:
! 3542: /* add to the stream size the current index */
! 3543: stream->stream_size += stream->stream_index;
! 3544:
! 3545: } /* end if */
! 3546:
! 3547: /* return result */
! 3548: return axl_true;
! 3549: }
! 3550:
! 3551: /**
! 3552: * @brief Function that allows to configure a handler that is executed
! 3553: * to check content read into the axl stream buffer. See \ref
! 3554: * axlStreamContentCheck for more information.
! 3555: *
! 3556: * @param stream The stream that is going to be configured.
! 3557: *
! 3558: * @param source_encoding The source encoding detected.
! 3559: *
! 3560: * @param check The function that implements the check.
! 3561: *
! 3562: * @param user_data User defined data to be passed to the check
! 3563: * function.
! 3564: *
! 3565: * @param error Optional \ref axlError reference where errors will be
! 3566: * reported.
! 3567: *
! 3568: * @return The function returns axl_true if the cheker was installed and
! 3569: * first execution was completed.
! 3570: */
! 3571: axl_bool axl_stream_setup_check (axlStream * stream,
! 3572: const char * source_encoding,
! 3573: axlStreamContentCheck check,
! 3574: axlPointer user_data,
! 3575: axlError ** error)
! 3576: {
! 3577: axl_return_val_if_fail (stream, axl_false);
! 3578:
! 3579: /* do not check if the decode_f function is NULL (it's a valid
! 3580: * case) */
! 3581: stream->check_f = check;
! 3582: stream->check_f_data = user_data;
! 3583:
! 3584: /* store source encoding */
! 3585: if (source_encoding != NULL)
! 3586: stream->source_encoding = axl_strdup (source_encoding);
! 3587:
! 3588: if (stream->check_f) {
! 3589: /* call to check */
! 3590: if (! axl_stream_content_check (stream, stream->stream + stream->stream_index, stream->stream_size - stream->stream_index, error)) {
! 3591: __axl_log (LOG_DOMAIN, AXL_LEVEL_CRITICAL, "content check function have failed, looks like there is a problem with content");
! 3592: return axl_false;
! 3593: } /* end if */
! 3594: } /* end if */
! 3595:
! 3596: return axl_true;
! 3597: }
! 3598:
! 3599: /* @} */
! 3600:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to axl_stream.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / gpl / axl / src