Annotation of libwww/Library/src/HTTee.c, revision 2.12

2.5       frystyk     1: /*                                                                      HTee.c
                      2: **     TEE CLASS STREAM DEFINITION
                      3: **
2.9       frystyk     4: **     (c) COPYRIGHT MIT 1995.
2.5       frystyk     5: **     Please first read the full copyright statement in the file COPYRIGH.
2.1       timbl       6: **
                      7: **     The Tee class just writes to two streams.  Easy.
                      8: **     See also the Black Hole stream which is even easier.
2.3       duns        9: **
                     10: ** HISTORY:
                     11: **      8 Jul 94  FM   Insulate free() from _free structure element.
                     12: **
2.1       timbl      13: */
                     14: 
2.7       frystyk    15: /* Library include files */
                     16: #include "tcp.h"
                     17: #include "HTUtils.h"
2.1       timbl      18: #include "HTTee.h"
                     19: 
                     20: /*             Stream Object
                     21: **             ------------
                     22: */
                     23: 
                     24: struct _HTStream {
                     25:        CONST HTStreamClass *   isa;
                     26:        
                     27:        HTStream *              s1;
                     28:        HTStream *              s2;
                     29: };
                     30: 
                     31: 
2.11      frystyk    32: PRIVATE int HTTee_put_character (HTStream * me, char c)
2.1       timbl      33: {
2.8       frystyk    34:     int ret1 = (*me->s1->isa->put_character)(me->s1, c);
                     35:     int ret2 = (*me->s2->isa->put_character)(me->s2, c);
2.12    ! frystyk    36: 
        !            37:     if (ret1 < 0)      /* howcome 6 dec 95 */
        !            38:         return ret1;
        !            39:     if (ret2 < 0)
        !            40:         return ret2;
        !            41:     if (ret1 == 0)
        !            42:         return ret2;
        !            43:     return ret1;
        !            44: 
        !            45: /*
2.8       frystyk    46:     return (!(ret1+ret2) ? HT_OK :
                     47:            (ret1==HT_ERROR || ret2==HT_ERROR) ? HT_ERROR :
                     48:            HT_WOULD_BLOCK);
2.12    ! frystyk    49: */
2.1       timbl      50: }
2.8       frystyk    51: 
2.11      frystyk    52: PRIVATE int HTTee_put_string (HTStream * me, CONST char* s)
2.1       timbl      53: {
2.8       frystyk    54:     int ret1 = (*me->s1->isa->put_string)(me->s1, s);
                     55:     int ret2 = (*me->s2->isa->put_string)(me->s2, s);
2.12    ! frystyk    56: 
        !            57:     if (ret1 < 0)      /* howcome 6 dec 95 */
        !            58:         return ret1;
        !            59:     if (ret2 < 0)
        !            60:         return ret2;
        !            61:     if (ret1 == 0)
        !            62:         return ret2;
        !            63:     return ret1;
        !            64: 
        !            65: /*
2.8       frystyk    66:     return (!(ret1+ret2) ? HT_OK :
                     67:            (ret1==HT_ERROR || ret2==HT_ERROR) ? HT_ERROR :
                     68:            HT_WOULD_BLOCK);
2.12    ! frystyk    69: */
2.1       timbl      70: }
2.8       frystyk    71: 
2.11      frystyk    72: PRIVATE int HTTee_write (HTStream * me, CONST char* s, int l)
2.1       timbl      73: {
2.8       frystyk    74:     int ret1 = (*me->s1->isa->put_block)(me->s1, s, l);
                     75:     int ret2 = (*me->s2->isa->put_block)(me->s2, s, l);
2.12    ! frystyk    76: 
        !            77:     if (ret1 < 0)      /* howcome 6 dec 95 */
        !            78:         return ret1;
        !            79:     if (ret2 < 0)
        !            80:         return ret2;
        !            81:     if (ret1 == 0)
        !            82:         return ret2;
        !            83:     return ret1;
        !            84: 
        !            85: /*
2.8       frystyk    86:     return (!(ret1+ret2) ? HT_OK :
                     87:            (ret1==HT_ERROR || ret2==HT_ERROR) ? HT_ERROR :
                     88:            HT_WOULD_BLOCK);
2.12    ! frystyk    89: */
2.1       timbl      90: }
2.8       frystyk    91: 
2.11      frystyk    92: PRIVATE int HTTee_flush (HTStream * me)
2.8       frystyk    93: {
                     94:     int ret1 = (*me->s1->isa->flush)(me->s1);
                     95:     int ret2 = (*me->s2->isa->flush)(me->s2);
2.12    ! frystyk    96: 
        !            97:     if (ret1 < 0)      /* howcome 6 dec 95 */
        !            98:         return ret1;
        !            99:     if (ret2 < 0)
        !           100:         return ret2;
        !           101:     if (ret1 == 0)
        !           102:         return ret2;
        !           103:     return ret1;
        !           104: 
        !           105: /*
2.8       frystyk   106:     return (!(ret1+ret2) ? HT_OK :
                    107:            (ret1==HT_ERROR || ret2==HT_ERROR) ? HT_ERROR :
                    108:            HT_WOULD_BLOCK);
2.12    ! frystyk   109: */
2.8       frystyk   110: }
                    111: 
2.11      frystyk   112: PRIVATE int HTTee_free (HTStream * me)
2.1       timbl     113: {
2.8       frystyk   114:     int ret1 = (*me->s1->isa->_free)(me->s1);
                    115:     int ret2 = (*me->s2->isa->_free)(me->s2);
2.2       luotonen  116:     free(me);
2.12    ! frystyk   117: 
        !           118:     if (ret1 < 0)      /* howcome 6 dec 95 */
        !           119:         return ret1;
        !           120:     if (ret2 < 0)
        !           121:         return ret2;
        !           122:     if (ret1 == 0)
        !           123:         return ret2;
        !           124:     return ret1;
        !           125: 
        !           126: /*
2.8       frystyk   127:     return (!(ret1+ret2) ? HT_OK :
                    128:            (ret1==HT_ERROR || ret2==HT_ERROR) ? HT_ERROR :
                    129:            HT_WOULD_BLOCK);
2.12    ! frystyk   130: */
2.1       timbl     131: }
2.8       frystyk   132: 
2.11      frystyk   133: PRIVATE int HTTee_abort (HTStream * me, HTList * e)
2.1       timbl     134: {
                    135:     (*me->s1->isa->abort)(me->s1, e);
                    136:     (*me->s2->isa->abort)(me->s2, e);
2.2       luotonen  137:     free(me);
2.8       frystyk   138:     return HT_ERROR;
2.1       timbl     139: }
                    140: 
                    141: 
                    142: /*     Tee stream
                    143: **     ----------
                    144: */
                    145: PRIVATE CONST HTStreamClass HTTeeClass =
                    146: {              
                    147:        "Tee",
2.8       frystyk   148:        HTTee_flush,
2.1       timbl     149:        HTTee_free,
                    150:        HTTee_abort,
                    151:        HTTee_put_character,    HTTee_put_string,
                    152:        HTTee_write
                    153: }; 
                    154: 
                    155: 
                    156: /*     Tee creation
                    157: */
2.11      frystyk   158: PUBLIC HTStream * HTTee (HTStream * s1,HTStream * s2)
2.1       timbl     159: {
2.8       frystyk   160:     HTStream * me = (HTStream *) calloc(1, sizeof(*me));
2.1       timbl     161:     if (!me) outofmem(__FILE__, "HTTee");
                    162:     me->isa = &HTTeeClass;
                    163:     me->s1 = s1;
                    164:     me->s2 = s2;
                    165:     return me;
                    166: }
                    167: 
                    168: 

Webmaster