1 /*********************************************************************** 2 * * 3 * This software is part of the ast package * 4 * Copyright (c) 1985-2009 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 /* Reserve a segment of data or buffer. 25 ** 26 ** Written by Kiem-Phong Vo. 27 */ 28 29 #if __STD_C 30 Void_t* sfreserve(Sfio_t* f, ssize_t size, int type) 31 #else 32 Void_t* sfreserve(f,size,type) 33 Sfio_t* f; /* file to peek */ 34 ssize_t size; /* size of peek */ 35 int type; /* LOCKR: lock stream, LASTR: last record */ 36 #endif 37 { 38 reg ssize_t n, now, sz, iosz; 39 reg Sfrsrv_t* rsrv; 40 reg Void_t* data; 41 reg int mode, local; 42 SFMTXDECL(f); 43 44 SFMTXENTER(f,NIL(Void_t*)); 45 46 sz = size < 0 ? -size : size; 47 48 /* see if we need to bias toward SF_WRITE instead of the default SF_READ */ 49 if(type < 0) 50 mode = 0; 51 else if((mode = type&SF_WRITE) ) 52 type &= ~SF_WRITE; 53 54 /* return the last record */ 55 if(type == SF_LASTR ) 56 { if((n = f->endb - f->next) > 0 && n == f->val ) 57 { data = (Void_t*)f->next; 58 f->next += n; 59 } 60 else if((rsrv = f->rsrv) && (n = -rsrv->slen) > 0) 61 { rsrv->slen = 0; 62 _Sfi = f->val = n; 63 data = (Void_t*)rsrv->data; 64 } 65 else 66 { _Sfi = f->val = -1; 67 data = NIL(Void_t*); 68 } 69 70 SFMTXRETURN(f, data); 71 } 72 73 if(type > 0) 74 { if(type == 1 ) /* upward compatibility mode */ 75 type = SF_LOCKR; 76 else if(type != SF_LOCKR) 77 SFMTXRETURN(f, NIL(Void_t*)); 78 } 79 80 if(size == 0 && (type < 0 || type == SF_LOCKR) ) 81 { if((f->mode&SF_RDWR) != f->mode && _sfmode(f,0,0) < 0) 82 SFMTXRETURN(f, NIL(Void_t*)); 83 84 SFLOCK(f,0); 85 if((n = f->endb - f->next) < 0) 86 n = 0; 87 88 goto done; 89 } 90 91 /* iterate until get to a stream that has data or buffer space */ 92 for(local = 0;; local = SF_LOCAL) 93 { _Sfi = f->val = -1; 94 95 if(!mode && !(mode = f->flags&SF_READ) ) 96 mode = SF_WRITE; 97 if((int)f->mode != mode && _sfmode(f,mode,local) < 0) 98 { SFOPEN(f,0); 99 SFMTXRETURN(f, NIL(Void_t*)); 100 } 101 102 SFLOCK(f,local); 103 104 if((n = now = f->endb - f->next) < 0) 105 n = 0; 106 if(n > 0 && n >= sz) /* all done */ 107 break; 108 109 /* set amount to perform IO */ 110 if(size == 0 || (f->mode&SF_WRITE)) 111 iosz = -1; 112 else if(size < 0 && n == 0 && f->push) /* maybe stack-pop */ 113 { if((iosz = f->push->endb - f->push->next) == 0) 114 iosz = f->push->size; 115 if(iosz < sz) 116 iosz = sz; /* so only get what is asked for */ 117 } 118 else 119 { iosz = sz - n; /* get enough to fulfill requirement */ 120 if(size < 0 && iosz < (f->size - n) ) 121 iosz = f->size - n; /* get as much as possible */ 122 if(iosz <= 0) /* nothing to do */ 123 break; 124 } 125 126 /* do a buffer refill or flush */ 127 now = n; 128 if(f->mode&SF_WRITE) 129 (void)SFFLSBUF(f, iosz); 130 else if(type == SF_LOCKR && f->extent < 0 && (f->flags&SF_SHARE) ) 131 { if(n == 0) /* peek-read only if there is no buffered data */ 132 { f->mode |= SF_RV; 133 (void)SFFILBUF(f, iosz ); 134 } 135 if((n = f->endb - f->next) < sz) 136 { if(f->mode&SF_PKRD) 137 { f->endb = f->endr = f->next; 138 f->mode &= ~SF_PKRD; 139 } 140 break; 141 } 142 } 143 else 144 { /* sfreserve(f,0,0) == sfread(f, sfreserve(f,-1,SF_LOCKR), 0) */ 145 if(size == 0 && type == 0) 146 f->mode |= SF_RV; 147 148 (void)SFFILBUF(f, iosz ); 149 } 150 151 if((n = f->endb - f->next) <= 0) 152 n = 0; 153 154 if(n >= sz) /* got it */ 155 break; 156 157 if(n == now || sferror(f) || sfeof(f)) /* no progress */ 158 break; 159 160 /* request was only to assess data availability */ 161 if(type == SF_LOCKR && size > 0 && n > 0 ) 162 break; 163 } 164 165 done: /* compute the buffer to be returned */ 166 data = NIL(Void_t*); 167 if(size == 0 || n == 0) 168 { if(n > 0) /* got data */ 169 data = (Void_t*)f->next; 170 else if(type == SF_LOCKR && size == 0 && (rsrv = _sfrsrv(f,0)) ) 171 data = (Void_t*)rsrv->data; 172 } 173 else if(n >= sz) /* got data */ 174 data = (Void_t*)f->next; 175 else if(f->flags&SF_STRING) /* try extending string buffer */ 176 { if((f->mode&SF_WRITE) && (f->flags&SF_MALLOC) ) 177 { (void)SFWR(f,f->next,sz,f->disc); 178 if((n = f->endb - f->next) >= sz ) 179 data = (Void_t*)f->next; 180 } 181 } 182 else if(f->mode&SF_WRITE) /* allocate side buffer */ 183 { if(type == SF_LOCKR && (rsrv = _sfrsrv(f, sz)) ) 184 data = (Void_t*)rsrv->data; 185 } 186 else if(type != SF_LOCKR && sz > f->size && (rsrv = _sfrsrv(f,sz)) ) 187 { if((n = SFREAD(f,(Void_t*)rsrv->data,sz)) >= sz) /* read side buffer */ 188 data = (Void_t*)rsrv->data; 189 else rsrv->slen = -n; 190 } 191 192 SFOPEN(f,0); 193 194 if(data) 195 { if(type == SF_LOCKR) 196 { f->mode |= SF_PEEK; 197 if((f->mode & SF_READ) && size == 0 && data != f->next) 198 f->mode |= SF_GETR; /* so sfread() will unlock */ 199 f->endr = f->endw = f->data; 200 } 201 else 202 { if(data == (Void_t*)f->next) 203 f->next += (size >= 0 ? size : n); 204 } 205 } 206 207 _Sfi = f->val = n; /* return true buffer size */ 208 209 SFMTXRETURN(f, data); 210 } 211