exdr_writed

SFL
Version 2.11

`exdr_writed`

#include "sflexdr.h"
int
exdr_writed (DESCR *buffer, const char *format, ...)

Synopsis

As exdr write(), but accepts a DESCR buffer. This is more secure. Aborts with an error if the formatted data would be too long for the buffer, if compiled with DEBUG. The buffer address cannot be NULL.

Source Code - (sflexdr.c)

{
    va_list
        argptr;                         /*  Argument list pointer            */
    byte
        *target,                        /*  Pointer into target buffer       */
        *block;                         /*  Source block for 'M' type        */
    char
        *string;                        /*  Source string for 's' type       */
    dbyte
        dbyte_value;                    /*  Network format dbyte value       */
    qbyte
        memory_size = 0,                /*  Memory descriptor size value     */
        qbyte_value;                    /*  Network format qbyte value       */
    size_t
        used_size;                      /*  Current buffer data size         */

    ASSERT (buffer);
    ASSERT (format);
    va_start (argptr, format);          /*  Start variable arguments list    */
    target = buffer-> data;

    while (*format)
      {
        used_size = (size_t) (target - buffer-> data);
        switch (*format++)
          {
            case 'c':                   /*  Character                        */
            case 'b':                   /*  Single byte                      */
                *(byte *) target = (byte) va_arg (argptr, int);
                ASSERT (used_size + 1 <= buffer-> size);
                target += 1;
                break;

            case 'd':                   /*  Signed short integer             */
            case 'w':                   /*  Unsigned short integer           */
            case 'B':                   /*  Bool                             */
                dbyte_value = htons ((short) va_arg (argptr, int));
                ASSERT (used_size + 2 <= buffer-> size);
                *(byte *) target++ = *((byte *) &dbyte_value);
                *(byte *) target++ = *((byte *) &dbyte_value + 1);
                break;

            case 'l':                   /*  Signed long (32-bit)             */
            case 'q':                   /*  4-byte unsigned value            */
                qbyte_value = htonl (va_arg (argptr, qbyte));
                ASSERT (used_size + 4 <= buffer-> size);
                *(byte *) target++ = *((byte *) &qbyte_value);
                *(byte *) target++ = *((byte *) &qbyte_value + 1);
                *(byte *) target++ = *((byte *) &qbyte_value + 2);
                *(byte *) target++ = *((byte *) &qbyte_value + 3);
                break;

            case 's':                   /*  Null-terminated string           */
                string = va_arg (argptr, char *);
                if (string)
                  {
                    ASSERT (used_size + strlen (string) + 1 <= buffer-> size);
                    strcpy ((char *) target, string);
                    target += strlen (string) + 1;
                  }
                else                    /*  Store NULL as single null byte   */
                  {
                    ASSERT (used_size + 1 <= buffer-> size);
                    *(byte *) target++ = 0;
                  }
                break;

            case 'm':                   /*  Memory descriptor size           */
                memory_size = va_arg (argptr, int);
                ASSERT (used_size + 2 + memory_size <= buffer-> size);
                dbyte_value = htons ((dbyte) memory_size);
                *(byte *) target++ = *((byte *) &dbyte_value);
                *(byte *) target++ = *((byte *) &dbyte_value + 1);
                break;
            case 'M':                   /*  Memory descriptor body           */
                block = va_arg (argptr, byte *);
                if (block)
                  {
                    memcpy (target, block, (size_t) memory_size);
                    target += (size_t) memory_size;
                  }
                else
                    ASSERT (memory_size == 0);
                break;

            case 'h':                   /*  Huge memory descriptor size      */
                memory_size = va_arg (argptr, qbyte);
                ASSERT (used_size + 4 + memory_size <= buffer-> size);
                qbyte_value = htonl (memory_size);
                *(byte *) target++ = *((byte *) &qbyte_value);
                *(byte *) target++ = *((byte *) &qbyte_value + 1);
                *(byte *) target++ = *((byte *) &qbyte_value + 2);
                *(byte *) target++ = *((byte *) &qbyte_value + 3);
                break;
            case 'H':                   /*  Huge memory descriptor body      */
                block = va_arg (argptr, byte *);
                if (block)
                  {
                    memcpy (target, block, (size_t) memory_size);
                    target += (size_t) memory_size;
                  }
                else
                    ASSERT (memory_size == 0);
                break;
          }
      }
    va_end (argptr);                    /*  End variable arguments list      */
    return ((int) (target - buffer-> data));
}

| << | < | > | >>