1 /*********************************************************************** 2 * * 3 * This software is part of the ast package * 4 * Copyright (c) 1985-2010 AT&T Intellectual Property * 5 * and is licensed under the * 6 * Common Public License, Version 1.0 * 7 * by AT&T Intellectual Property * 8 * * 9 * A copy of the License is available at * 10 * http://www.opensource.org/licenses/cpl1.0.txt * 11 * (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) * 12 * * 13 * Information and Software Systems Research * 14 * AT&T Research * 15 * Florham Park NJ * 16 * * 17 * Glenn Fowler <gsf@research.att.com> * 18 * David Korn <dgk@research.att.com> * 19 * Phong Vo <kpv@research.att.com> * 20 * * 21 ***********************************************************************/ 22 #include "sfhdr.h" 23 24 /* Add a new discipline to the discipline stack. Each discipline 25 ** provides alternative I/O functions that are analogues of the 26 ** system calls. 27 ** 28 ** When the application fills or flushes the stream buffer, data 29 ** will be processed through discipline functions. A case deserving 30 ** consideration is stacking a discipline onto a read stream. Each 31 ** discipline operation implies buffer synchronization so the stream 32 ** buffer should be empty. However, a read stream representing an 33 ** unseekable device (eg, a pipe) may not be synchronizable. In that 34 ** case, any buffered data must then be fed to the new discipline 35 ** to preserve data processing semantics. This is done by creating 36 ** a temporary discipline to cache such buffered data and feed 37 ** them to the new discipline when its readf() asks for new data. 38 ** Care must then be taken to remove this temporary discipline 39 ** when it runs out of cached data. 40 ** 41 ** Written by Kiem-Phong Vo 42 */ 43 44 typedef struct _dccache_s 45 { Sfdisc_t disc; 46 uchar* data; 47 uchar* endb; 48 } Dccache_t; 49 50 #if __STD_C 51 static int _dccaexcept(Sfio_t* f, int type, Void_t* val, Sfdisc_t* disc) 52 #else 53 static int _dccaexcept(f,type,val,disc) 54 Sfio_t* f; 55 int type; 56 Void_t* val; 57 Sfdisc_t* disc; 58 #endif 59 { 60 if(disc && type == SF_FINAL) 61 free(disc); 62 return 0; 63 } 64 65 #if __STD_C 66 static ssize_t _dccaread(Sfio_t* f, Void_t* buf, size_t size, Sfdisc_t* disc) 67 #else 68 static ssize_t _dccaread(f, buf, size, disc) 69 Sfio_t* f; 70 Void_t* buf; 71 size_t size; 72 Sfdisc_t* disc; 73 #endif 74 { 75 ssize_t sz; 76 Sfdisc_t *prev; 77 Dccache_t *dcca; 78 79 if(!f) /* bad stream */ 80 return -1; 81 82 /* make sure that this is on the discipline stack */ 83 for(prev = f->disc; prev; prev = prev->disc) 84 if(prev->disc == disc) 85 break; 86 if(!prev) 87 return -1; 88 89 if(size <= 0) /* nothing to do */ 90 return size; 91 92 /* read from available data */ 93 dcca = (Dccache_t*)disc; 94 if((sz = dcca->endb - dcca->data) > (ssize_t)size) 95 sz = (ssize_t)size; 96 memcpy(buf, dcca->data, sz); 97 98 if((dcca->data += sz) >= dcca->endb) /* free empty cache */ 99 { prev->disc = disc->disc; 100 free(disc); 101 } 102 103 return sz; 104 } 105 106 #if __STD_C 107 Sfdisc_t* sfdisc(Sfio_t* f, Sfdisc_t* disc) 108 #else 109 Sfdisc_t* sfdisc(f,disc) 110 Sfio_t* f; 111 Sfdisc_t* disc; 112 #endif 113 { 114 Sfdisc_t *d, *rdisc; 115 Sfread_f oreadf; 116 Sfwrite_f owritef; 117 Sfseek_f oseekf; 118 ssize_t n; 119 Dccache_t *dcca = NIL(Dccache_t*); 120 SFMTXDECL(f); 121 122 SFMTXENTER(f, NIL(Sfdisc_t*)); 123 124 if((Sfio_t*)disc == f) /* special case to get the top discipline */ 125 SFMTXRETURN(f,f->disc); 126 127 if((f->flags&SF_READ) && f->proc && (f->mode&SF_WRITE) ) 128 { /* make sure in read mode to check for read-ahead data */ 129 if(_sfmode(f,SF_READ,0) < 0) 130 SFMTXRETURN(f, NIL(Sfdisc_t*)); 131 } 132 else 133 { if((f->mode&SF_RDWR) != f->mode && _sfmode(f,0,0) < 0) 134 SFMTXRETURN(f, NIL(Sfdisc_t*)); 135 } 136 137 SFLOCK(f,0); 138 rdisc = NIL(Sfdisc_t*); 139 140 /* disallow popping while there is cached data */ 141 if(!disc && f->disc && f->disc->disc && f->disc->disc->readf == _dccaread ) 142 goto done; 143 144 /* synchronize before switching to a new discipline */ 145 if(!(f->flags&SF_STRING)) 146 { (void)SFSYNC(f); /* do a silent buffer synch */ 147 if((f->mode&SF_READ) && (f->mode&SF_SYNCED) ) 148 { f->mode &= ~SF_SYNCED; 149 f->endb = f->next = f->endr = f->endw = f->data; 150 } 151 152 /* if there is buffered data, ask app before proceeding */ 153 if(((f->mode&SF_WRITE) && (n = f->next-f->data) > 0) || 154 ((f->mode&SF_READ) && (n = f->endb-f->next) > 0) ) 155 { int rv = 0; 156 if(rv == 0 && f->disc && f->disc->exceptf) /* ask current discipline */ 157 { SFOPEN(f,0); 158 rv = (*f->disc->exceptf)(f, SF_DBUFFER, &n, f->disc); 159 SFLOCK(f,0); 160 } 161 if(rv == 0 && disc && disc->exceptf) /* ask discipline being pushed */ 162 { SFOPEN(f,0); 163 rv = (*disc->exceptf)(f, SF_DBUFFER, &n, disc); 164 SFLOCK(f,0); 165 } 166 if(rv < 0) 167 goto done; 168 } 169 170 /* trick the new discipline into processing already buffered data */ 171 if((f->mode&SF_READ) && n > 0 && disc && disc->readf ) 172 { if(!(dcca = (Dccache_t*)malloc(sizeof(Dccache_t)+n)) ) 173 goto done; 174 memclear(dcca, sizeof(Dccache_t)); 175 176 dcca->disc.readf = _dccaread; 177 dcca->disc.exceptf = _dccaexcept; 178 179 /* move buffered data into the temp discipline */ 180 dcca->data = ((uchar*)dcca) + sizeof(Dccache_t); 181 dcca->endb = dcca->data + n; 182 memcpy(dcca->data, f->next, n); 183 f->endb = f->next = f->endr = f->endw = f->data; 184 } 185 } 186 187 /* save old readf, writef, and seekf to see if stream need reinit */ 188 #define GETDISCF(func,iof,type) \ 189 { for(d = f->disc; d && !d->iof; d = d->disc) ; \ 190 func = d ? d->iof : NIL(type); \ 191 } 192 GETDISCF(oreadf,readf,Sfread_f); 193 GETDISCF(owritef,writef,Sfwrite_f); 194 GETDISCF(oseekf,seekf,Sfseek_f); 195 196 if(disc == SF_POPDISC) 197 { /* popping, warn the being popped discipline */ 198 if(!(d = f->disc) ) 199 goto done; 200 disc = d->disc; 201 if(d->exceptf) 202 { SFOPEN(f,0); 203 if((*(d->exceptf))(f,SF_DPOP,(Void_t*)disc,d) < 0 ) 204 goto done; 205 SFLOCK(f,0); 206 } 207 f->disc = disc; 208 rdisc = d; 209 } 210 else 211 { /* pushing, warn being pushed discipline */ 212 do 213 { /* loop to handle the case where d may pop itself */ 214 d = f->disc; 215 if(d && d->exceptf) 216 { SFOPEN(f,0); 217 if( (*(d->exceptf))(f,SF_DPUSH,(Void_t*)disc,d) < 0 ) 218 goto done; 219 SFLOCK(f,0); 220 } 221 } while(d != f->disc); 222 223 /* make sure we are not creating an infinite loop */ 224 for(; d; d = d->disc) 225 if(d == disc) 226 goto done; 227 228 /* set new disc */ 229 if(dcca) /* insert the discipline with cached data */ 230 { dcca->disc.disc = f->disc; 231 disc->disc = &dcca->disc; 232 } 233 else disc->disc = f->disc; 234 f->disc = disc; 235 rdisc = disc; 236 } 237 238 if(!(f->flags&SF_STRING) ) 239 { /* this stream may have to be reinitialized */ 240 reg int reinit = 0; 241 #define DISCF(dst,iof,type) (dst ? dst->iof : NIL(type)) 242 #define REINIT(oiof,iof,type) \ 243 if(!reinit) \ 244 { for(d = f->disc; d && !d->iof; d = d->disc) ; \ 245 if(DISCF(d,iof,type) != oiof) \ 246 reinit = 1; \ 247 } 248 249 REINIT(oreadf,readf,Sfread_f); 250 REINIT(owritef,writef,Sfwrite_f); 251 REINIT(oseekf,seekf,Sfseek_f); 252 253 if(reinit) 254 { SETLOCAL(f); 255 f->bits &= ~SF_NULL; /* turn off /dev/null handling */ 256 if((f->bits&SF_MMAP) || (f->mode&SF_INIT)) 257 sfsetbuf(f,NIL(Void_t*),(size_t)SF_UNBOUND); 258 else if(f->data == f->tiny) 259 sfsetbuf(f,NIL(Void_t*),0); 260 else 261 { int flags = f->flags; 262 sfsetbuf(f,(Void_t*)f->data,f->size); 263 f->flags |= (flags&SF_MALLOC); 264 } 265 } 266 } 267 268 done : 269 SFOPEN(f,0); 270 SFMTXRETURN(f, rdisc); 271 } 272