Debian Codegraph @

lib/aviread/AsfNetworkInputStream.cpp

raw ◀ ▶
Source reconstructed at patch state 0 of 1 — not the installed (fully patched) source.
1 Debian patch touch this file
1
2 #include "AsfNetworkInputStream.h"
3 #include "AsxReader.h"
4 #include "asf_guids.h"
5 #include "utils.h"
6 #include "avm_output.h"
7
8 #include <errno.h>
9 #include <unistd.h>
10 #include <fcntl.h>
11 #include <sys/types.h>
12 #include <sys/time.h>
13 #include <sys/socket.h>
14 #include <netinet/in.h>
15 #include <arpa/inet.h>
16 #include <netdb.h>
17
18 #include <ctype.h>
19 #include <stdlib.h> // atoi
20 #include <string.h> // strerror
21 #include <stdio.h>
22
23 // FIXME - fix new elements here
24
25 AVM_BEGIN_NAMESPACE;
26
27 static int l_iFd = -1;
28
29 #define USERAGENT "User-Agent: NSPlayer/7.1.0.3055\r\n"
30 #define CLIENTGUID "Pragma: xClientGUID={c77e7400-738a-11d2-9add-0020af0a3278}\r\n"
31
32 static const char m_pcFirstRequest[] =
33 "GET %s HTTP/1.0\r\n"
34 "Accept: */*\r\n"
35 USERAGENT
36 "Host: %s\r\n"
37 "Pragma: no-cache,rate=1.000000,stream-time=0,stream-offset=0:0,request-context=%u,max-duration=0\r\n"
38 CLIENTGUID
39 "Connection: Close\r\n\r\n";
40
41 static const char m_pcSeekableRequest[] =
42 "GET %s HTTP/1.0\r\n"
43 "Accept: */*\r\n"
44 USERAGENT
45 "Host: %s\r\n"
46 "Pragma: no-cache,rate=1.000000,stream-time=%u,stream-offset=%u:%u,request-context=%u,max-duration=%u\r\n"
47 CLIENTGUID
48 "Pragma: xPlayStrm=1\r\n"
49 "Pragma: stream-switch-count=%d\r\n"
50 "Pragma: stream-switch-entry=%s\r\n" // ffff:1:0 ffff:2:0
51 "Connection: Close\r\n\r\n";
52
53 static const char m_pcPostRequest[] =
54 "POST %s HTTP/1.0\r\n"
55 "Accept: */*\r\n"
56 USERAGENT
57 "Host: %s\r\n"
58 "Pragma: client-id=%u\r\n"
59 //"Pragma: log-line=no-cache,rate=1.000000,stream-time=%u,stream-offset=%u:%u,request-context=2,max-duration=%u\r\n"
60 "Pragma: Content-Length: 0\r\n"
61 CLIENTGUID
62 "\r\n";
63
64 static const char m_pcLiveRequest[] =
65 "GET %s HTTP/1.0\r\n"
66 "Accept: */*\r\n"
67 USERAGENT
68 "Host: %s\r\n"
69 "Pragma: no-cache,rate=1.000000,request-context=%u\r\n"
70 "Pragma: xPlayStrm=1\r\n"
71 CLIENTGUID
72 "Pragma: stream-switch-count=%d\r\n"
73 "Pragma: stream-switch-entry=%s\r\n"
74 "Connection: Close\r\n\r\n";
75
76 static const char m_pcRangeRequest[] =
77 "GET %s HTTP/1.0\r\n"
78 "Accept: */*\r\n"
79 USERAGENT
80 "Host: %s\r\n"
81 "Range: bytes=%llu-\r\n"
82 CLIENTGUID
83 "Connection: Close\r\n\r\n";
84
85
86
87 class AsfNetworkInputStream;
88 class AsfStreamSeekInfo;
89
90 class NetworkIterator: public AsfIterator
91 {
92 friend class AsfNetworkInputStream;
93 public:
94 NetworkIterator(AsfNetworkInputStream* parent, int id)
95 : AsfIterator(id), m_pParent(parent)
96 {
97 }
98 virtual ~NetworkIterator()
99 {
100 for (uint_t i = 0; i < m_Packets.size(); i++)
101 m_Packets[i]->release();
102 }
103 virtual const AsfStreamSeekInfo* getSeekInfo()
104 {
105 return 0;
106 }
107 virtual AsfPacket* getPacket()
108 {
109 AVM_WRITE("ASF network reader", 1, "getPacket() (Eof: %d, pkts: %" PRIsz ")\n", m_bEof, m_Packets.size());
110 PthreadMutex& mutex = m_pParent->m_Mutex;
111 PthreadCond& cond = m_pParent->m_Cond;
112 Locker locker(mutex);
113
114 for (int i = 0; !m_Packets.size(); i++)
115 {
116 if (m_bEof || i > 20)
117 return 0;
118 if (!m_pParent->m_bWaiting)
119 cond.Broadcast();
120 cond.Wait(mutex, 0.5);
121 //printf("WAIT %d\n", i);
122 }
123
124 //for (int i = 0; i < m_Packets.size(); i++)
125 // AVM_WRITE("ASF network reader", "GETPACKETLIST %d %p %d\n", i, m_Packets[i], m_Packets[i]->size());
126 AsfPacket* p = m_Packets.front();
127 m_Packets.pop_front();
128 //AVM_WRITE("ASF network reader", "packet %d p:%d\n", m_Packets.size(), p->send_time);
129 //AVM_WRITE("ASF network reader", 1, "Returning: length %d, send time %dms (%d)\n",
130 // p->packet_length, p->send_time, p->length);
131 return p;
132 }
133 virtual bool isEof() { return m_bEof && !m_Packets.size(); }
134 virtual int seek(framepos_t pos, chunk_info* pch)
135 {
136 AVM_WRITE("ASF network reader", "WARNING: seek(%u) is unsupported\n", pos);
137 return -1;
138 }
139 virtual int seekTime(double timestamp, chunk_info* pch)
140 {
141 if (m_pParent->seekInternal(uint_t(timestamp*1000.0), this) < 0)
142 return -1;
143
144 PthreadMutex& mutex = m_pParent->m_Mutex;
145 PthreadCond& cond = m_pParent->m_Cond;
146 Locker locker(mutex);
147
148 int i = 0;
149 while (i++ < 20 && !m_pParent->m_bQuit && !m_bEof && !m_Packets.size())
150 {
151 AVM_WRITE("ASF network reader", "waiting & sleeping (%d, %d, %d)\n", i, m_bEof, m_iId);
152 cond.Broadcast();
153 cond.Wait(mutex, 0.5);
154 }
155 if (m_Packets.size())
156 {
157 AsfPacket* p = m_Packets.front();
158 pch->SetKeyFrame(true);
159 pch->fragment_id = 0;
160 pch->object_start_time = p->send_time;
161 return 0;
162 }
163 // hmmm
164 pch->SetKeyFrame(true);
165 pch->fragment_id = 0;
166 pch->object_start_time = m_pParent->m_uiTime;
167 return 0;
168 }
169 protected:
170 void setEof(bool b) { m_bEof = b; }
171 avm::vector<AsfPacket*> m_Packets;
172 AsfNetworkInputStream* m_pParent;
173 };
174
175 int AsfNetworkInputStream::init(const char* pszFile)
176 {
177 m_iSocket = m_lfd = m_iSeekId = -1;
178 m_bHeadersValid = false;
179 m_bAcceptRanges = false;
180 m_bFinished = false;
181 m_bWaiting = false;
182 m_bQuit = false;
183
184 m_Ctype = Unknown;
185 m_uiTime = 0;
186 m_pReader = 0;
187 m_Server = pszFile;
188 m_uiDataOffset = 0;
189 m_uiTimeshift = 0;
190 m_iRedirectSize = 16000;
191 m_iReadSize = 0;
192 m_iProxyport = 0;
193 pipe(m_iPipeFd);
194
195 avm::string::size_type start = 0, end;
196
197 AVM_WRITE("ASF network reader", 1, "checking URL: %s\n", m_Server.c_str());
198 for (;;)
199 {
200 start = m_Server.find("://", start);
201 if (start == avm::string::npos || start + 3 >= m_Server.size())
202 {
203 AVM_WRITE("ASF network reader", 1, "Not an URL\n");
204 return -1;
205 }
206 // find & use last occurence of ://
207 if (m_Server.find("://", start + 1) == avm::string::npos)
208 break;
209 start++;
210 }
211 start += 3;
212 end = m_Server.find("/", start);
213 if (end == avm::string::npos)
214 {
215 AVM_WRITE("ASF network reader", "Not an URL\n");
216 return -1;
217 }
218
219 m_ServerFilename = m_Server.substr(0, end);
220 m_Filename = m_Server.substr(end);
221 m_Filename.escape();
222 m_Server = m_Server.substr(start, end-start);
223
224 end = m_Server.find(":", start);
225 if (end == avm::string::npos)
226 m_Server += ":80";
227
228 //m_iServerport = atoi(m_Server.substr(end+1).c_str());
229 //m_Server = m_Server.substr(0,end);
230 AVM_WRITE("ASF network reader", "server:%s filename:%s\n", m_Server.c_str(), m_Filename.c_str());
231 // style hostname:port eg 192.168.10.10:8080
232 char* proxyenv = getenv("HTTP_PROXY");
233 if (!proxyenv)
234 proxyenv = getenv("http_proxy");
235 if (proxyenv)
236 {
237 if ((strncasecmp(proxyenv, "http://", 7) == 0))
238 proxyenv += 7;
239 m_Proxyhost = proxyenv;
240 end = m_Proxyhost.find(":");
241 if (end==avm::string::npos)
242 m_iProxyport = 80;
243 else
244 {
245 avm::string p = m_Proxyhost.substr(end + 1,avm::string::npos);
246 m_iProxyport = (uint16_t)atoi(p.c_str());
247 }
248 m_Proxyhost = m_Proxyhost.substr(0, end);
249 m_ServerFilename += m_Filename;
250 AVM_WRITE("ASF network reader", "proxy host:%s port:%d\n", m_Proxyhost.c_str(), m_iProxyport);
251 }
252 else
253 m_ServerFilename = m_Filename;
254
255 /*
256 * This func tries to open URL m_File. If it succeeds,
257 * it loads its headers, puts true to m_bHeadersValid
258 * and starts caching packets. If it fails, it puts
259 * true to m_bHeadersValid and to m_bQuit, and then exits.
260 */
261 // use some randomized name
262 srand((unsigned int) avm_get_time_us());
263 m_iRandcntx = rand();
264
265 // determine max size for posted requests
266 size_t max_request = strlen(m_pcLiveRequest);
267 size_t sz = strlen(m_pcSeekableRequest);
268 if (sz > max_request)
269 max_request = sz;
270 sz = strlen(m_pcFirstRequest);
271 if (sz > max_request)
272 max_request = sz;
273 max_request += m_Filename.size() + m_Server.size() + 512;
274 if (max_request < 65536)
275 max_request = 65536;
276 m_pBuffer = new char[max_request];
277
278 if (getenv("WRITE_ASFLOG") && l_iFd < 0)
279 l_iFd = open("./log", O_WRONLY|O_CREAT|O_TRUNC, 00666);
280
281 m_pThread = new PthreadTask(0, &AsfNetworkInputStream::threadStarter, this);
282 return 0;
283 }
284
285 AsfNetworkInputStream::~AsfNetworkInputStream()
286 {
287 m_bQuit = true;
288 interrupt();
289 delete m_pThread;
290 clear();
291 avm::vector<NetworkIterator*>::iterator it2;
292 for (it2 = m_Iterators.begin(); it2 != m_Iterators.end(); it2++)
293 (*it2)->release();
294 close(m_iPipeFd[0]);
295 close(m_iPipeFd[1]);
296 delete[] m_pBuffer;
297 delete m_pReader;
298 }
299
300 bool AsfNetworkInputStream::isValid()
301 {
302 if (m_bFinished)
303 {
304 Locker locker(m_Mutex);
305 if (m_Iterators.size())
306 {
307 size_t s = 0;
308 for(avm::vector<NetworkIterator*>::iterator it2 = m_Iterators.begin();
309 it2 != m_Iterators.end(); it2++)
310 s += (*it2)->m_Packets.size();
311 if (!s)
312 {
313 //printf("BROADCAST\n");
314 m_Cond.Broadcast();
315 }
316 }
317 }
318 return ((m_bHeadersValid && !m_bQuit) || m_pReader);
319 }
320
321 void AsfNetworkInputStream::flushPipe()
322 {
323 int pipe_flags = fcntl(m_iPipeFd[0], F_GETFL);
324 char c;
325 fcntl(m_iPipeFd[0], F_SETFL, pipe_flags | O_NONBLOCK);
326 while (::read(m_iPipeFd[0], &c, 1) > 0)
327 ;
328 fcntl(m_iPipeFd[0], F_SETFL, pipe_flags);
329 }
330
331 /* time in milliseconds */
332 int AsfNetworkInputStream::seekInternal(uint_t seektime, NetworkIterator* requester)
333 {
334 if (m_Ctype == Live
335 || (m_Ctype == Plain
336 && (!m_bAcceptRanges || !m_uiDataOffset)))
337 {
338 if (seektime == 0)
339 {
340 m_bFinished = true; // stop reading
341 clear();
342 }
343 return -1;
344 }
345
346 if (m_iSeekId < 0)
347 m_iSeekId = requester->getId();
348
349 if (m_iSeekId != requester->getId())
350 return 0;
351
352 int d = (m_uiTime > seektime) ? m_uiTime - seektime : seektime - m_uiTime;
353 //printf("DIFFERENCE %d\n", d);
354 if (d < 2000)
355 return 0; // ignore too close seeks
356
357 //AVM_WRITE("ASF network reader", "***********SEEKINTERNAL %d\n", seektime);
358 m_bFinished = true;
359 if (!m_bWaiting)
360 {
361 interrupt();
362 while (!m_bQuit && !m_bWaiting)
363 {
364 //printf("SLEEP %d %d\n", m_bQuit, m_bWaiting);
365 avm_usleep(100000);
366 }
367 }
368 m_uiTime = seektime;
369 interrupt();
370 m_bWaiting = false;
371 return 0;
372 }
373
374 void AsfNetworkInputStream::unregister(NetworkIterator* it)
375 {
376 m_Iterators.remove(it);
377 }
378
379 void AsfNetworkInputStream::interrupt()
380 {
381 AVM_WRITE("ASF network reader", 1, "interrupt()\n");
382 Locker locker(m_Mutex);
383 m_Cond.Broadcast();
384 char c = 0;
385 ::write(m_iPipeFd[1], &c, 1);
386 }
387
388 double AsfNetworkInputStream::cacheSize() const
389 {
390 Locker locker(m_Mutex);
391 AVM_WRITE("ASF network reader", 1, "cacheSize() finished: %d\n", m_bFinished);
392 if (m_bFinished) return 1.;
393
394 size_t min = m_Iterators.size() ? CACHE_PACKETS : 0;
395 for(avm::vector<NetworkIterator*>::const_iterator it2 = m_Iterators.begin();
396 it2!=m_Iterators.end(); it2++)
397 {
398 size_t s = (*it2)->m_Packets.size();
399 //AVM_WRITE("ASF network reader", "cachesz %d\n", s);
400 if (s < min)
401 min = s;
402 }
403 //AVM_WRITE("ASF network reader", "cacheSizeMin %d\n", min);
404 return (double)min / (double)CACHE_PACKETS;
405 }
406
407 void AsfNetworkInputStream::clear()
408 {
409 AVM_WRITE("ASF network reader", 1, "clear()\n");
410 Locker locker(m_Mutex);
411 for(avm::vector<NetworkIterator*>::iterator it2 = m_Iterators.begin();
412 it2!=m_Iterators.end(); it2++)
413 {
414 //printf("SIZE %d\n", (*it2)->m_Packets.size());
415 for (uint_t i = 0; i < (*it2)->m_Packets.size(); i++)
416 (*it2)->m_Packets[i]->release();
417
418 (*it2)->m_Packets.clear(); //FIXME - release
419 }
420 }
421
422 void* AsfNetworkInputStream::threadFunc()
423 {
424 int result = -1;
425 m_lReadBytes = 0;
426
427 if (createSocket() < 0)
428 goto terminated;
429
430 m_lfd = -12345;
431 sprintf(m_pBuffer, m_pcFirstRequest,
432 m_ServerFilename.c_str(), m_Server.c_str(), m_iRandcntx);
433 AVM_WRITE("ASF network reader", 1, "Request1 [ %s ]\n", m_pBuffer);
434 m_Ctype = checkContent(m_pBuffer);
435
436 switch (m_Ctype)
437 {
438 case Unknown:
439 AVM_WRITE("ASF network reader", "Unknown Content-Type - closing...\n");
440 goto terminated;
441 case Redirect:
442 AVM_WRITE("ASF network reader", "Redirector\n");
443 if (readRedirect() == 0)
444 goto ok;
445 goto terminated;
446 case Plain:
447 break;
448 default:
449 // reopen for broadcasted prerecorder & live streams
450 // user can select which streams he wants to receive
451 close(m_iSocket);
452 m_iSocket = -1;
453 }
454
455 while(!m_bQuit)
456 {
457 size_t scnt;
458 avm::string sffff;
459 m_bFinished = true;
460 m_Mutex.Lock();
461 if (!m_Iterators.size())
462 m_Cond.Wait(m_Mutex); // wait for read or IsValid
463 avm::vector<NetworkIterator*>::iterator it2;
464 for(it2 = m_Iterators.begin(); it2 != m_Iterators.end(); it2++)
465 (*it2)->setEof(false);
466 for (avm::vector<ASFStreamHeader>::iterator it = m_Streams.begin();
467 it != m_Streams.end(); it++)
468 {
469 int id = (*it).hdr.stream & 0x7f;
470 bool in = false;
471 for (it2 = m_Iterators.begin(); it2 != m_Iterators.end(); it2++)
472 if ((*it2)->getId() == id)
473 {
474 in = true;
475 break;
476 }
477 char b[30];
478 sprintf(b, "ffff:%d:%d ", id, (in) ? 0 : 2);
479 sffff += b;
480 }
481 scnt = m_Streams.size();
482 m_Mutex.Unlock();
483 clear();
484 if (m_iSocket < 0)
485 {
486 if (createSocket() < 0)
487 goto terminated;
488 }
489 //printf("INIT %d %s\n", scnt, sffff.c_str());
490 switch(m_Ctype)
491 {
492 case Prerecorded:
493 // CHECK which stream are actually requested by user
494 sprintf(m_pBuffer, m_pcSeekableRequest,
495 m_ServerFilename.c_str(),
496 m_Server.c_str(),
497 m_uiTime,
498 ~0, ~0, // offset
499 m_iRandcntx,
500 0x7FFFFFFF,
501 scnt, sffff.c_str() // stream_count
502 //4, "ffff:1:0 ffff:2:0 ffff:3:0 ffff:4:0"
503 );
504 AVM_WRITE("ASF network reader", 1, "Requesting prerecorded [ %s ]\n", m_pBuffer);
505 m_Ctype = checkContent(m_pBuffer);
506 break;
507 case Live:
508 sprintf(m_pBuffer, m_pcLiveRequest,
509 m_ServerFilename.c_str(),
510 m_Server.c_str(),
511 m_iRandcntx,
512 scnt, sffff.c_str() // stream_count
513 );
514 m_Ctype = checkContent(m_pBuffer);
515 AVM_WRITE("ASF network reader", 1, "Requesting live [ %s ]\n", m_pBuffer);
516 break;
517 case Plain:
518 if (m_bAcceptRanges && m_uiDataOffset && m_Header.max_bitrate)
519 {
520 // estimate packet in the file
521 int64_t o = (int64_t) m_Header.max_bitrate * (int64_t) m_uiTime;
522 o /= (8 * 1000); // bits -> bytes * milisec -> sec
523 o = (o / m_Header.max_pktsize) * m_Header.max_pktsize;
524 o += m_uiDataOffset;
525 sprintf(m_pBuffer, m_pcRangeRequest,
526 m_ServerFilename.c_str(),
527 m_Server.c_str(),
528 o,
529 m_iRandcntx
530 );
531 AVM_WRITE("ASF network reader", 1, "Requesting range [ %s ]\n", m_pBuffer);
532 m_Ctype = checkContent(m_pBuffer);
533 }
534 default:
535 break;
536 }
537
538 if (m_Ctype == Unknown)
539 {
540 AVM_WRITE("ASF network reader", "threadFunc() unknown Content-Type\n");
541 }
542 else
543 {
544 if (readContent() < 0) // main reading loop
545 AVM_WRITE("ASF network reader", "read_content() aborted\n");
546 else
547 AVM_WRITE("ASF network reader", "read_content() successful\n");
548 m_uiTime = 0;
549 }
550
551 if (m_bQuit)
552 goto terminated;
553
554 switch (m_Ctype)
555 {
556 case Prerecorded:
557 sprintf(m_pBuffer, m_pcPostRequest,
558 m_ServerFilename.c_str(),
559 m_Server.c_str(),
560 m_iRandcntx);
561 AVM_WRITE("ASF network reader", 1, "Posting prerecorded [ %s ]\n", m_pBuffer);
562 write(m_pBuffer, strlen(m_pBuffer));
563 default:
564 break;
565 }
566 m_Mutex.Lock();
567 m_bWaiting = true;
568 close(m_iSocket);
569 m_iSocket = -1;
570 AVM_WRITE("ASF network reader", "Waiting for wake up\n");
571 m_Cond.Broadcast();
572 m_Cond.Wait(m_Mutex);
573 m_Mutex.Unlock();
574 flushPipe();
575 AVM_WRITE("ASF network reader", "Continuing...\n");
576 }
577 result = 0;
578 goto ok;
579
580 terminated:
581 m_bHeadersValid = true;
582 m_bQuit = true;
583 ok:
584 m_Mutex.Lock();
585 for(avm::vector<NetworkIterator*>::iterator it2 = m_Iterators.begin();
586 it2 != m_Iterators.end(); it2++)
587 (*it2)->setEof(true);
588 m_Cond.Broadcast();
589 m_Mutex.Unlock();
590 clear();
591 delete[] m_pBuffer;
592 m_pBuffer = 0;
593 if (m_iSocket >= 0)
594 close(m_iSocket);
595 m_iSocket = -1;
596 flushPipe();
597 return (void*)result;
598 }
599
600 void* AsfNetworkInputStream::threadStarter(void* arg)
601 {
602 return ((AsfNetworkInputStream*)arg)->threadFunc();
603 }
604
605 int AsfNetworkInputStream::createSocket()
606 {
607 avm::string sn;
608 int proxyport;
609 uint16_t sp;
610
611 h_errno = 0;
612 if (m_iProxyport != 0)
613 {
614 sp = m_iProxyport;
615 sn = m_Proxyhost.c_str();
616 }
617 else
618 {
619 avm::string::size_type end = m_Server.find(":");
620 assert(end != avm::string::npos);
621 sp = (uint16_t)atoi(m_Server.substr(end + 1).c_str());
622 sn = m_Server.substr(0, end);
623 }
624
625 // if(!inet_aton(m_Server.c_str(), &sa.sin_addr))
626 hostent* he = gethostbyname(sn.c_str());
627 if (!he || !he->h_addr_list || !he->h_addr_list[0])
628 {
629 AVM_WRITE("ASF network reader", "Warning: could not resolve server name %s:%d ( %s )\n",
630 sn.c_str(), sp, strerror(h_errno));
631 return -1;
632 }
633
634 sockaddr_in sa;
635 memset(&sa, 0, sizeof(sa));
636 sa.sin_family = (sa_family_t) he->h_addrtype;
637 sa.sin_port = htons(sp);
638 sa.sin_addr = *(in_addr*)(he->h_addr_list[0]);
639
640 m_iSocket = socket(he->h_addrtype, SOCK_STREAM, 0);
641 if (m_iSocket < 0)
642 {
643 AVM_WRITE("ASF network reader", "Socket() failed ( %s )\n", strerror(errno));
644 return -1;
645 }
646
647 int oflg = fcntl(m_iSocket, F_GETFL);
648 fcntl(m_iSocket, F_SETFL, oflg | O_NONBLOCK);
649 int r = connect(m_iSocket, (sockaddr*)&sa, sizeof(sa));
650 if (r == -1 && errno == EINPROGRESS)
651 {
652 int maxtry = 50; // hmm should be settable by user ???
653 while (!m_bQuit && --maxtry >= 0)
654 {
655 fd_set wset;
656 fd_set rset;
657 int mx = (m_iSocket > m_iPipeFd[0]) ? m_iSocket : m_iPipeFd[0];
658 struct timeval tout = { 1, 0 }; // 1s timeout
659 FD_ZERO(&wset);
660 FD_ZERO(&rset);
661 FD_SET(m_iSocket, &wset);
662 FD_SET(m_iPipeFd[0], &rset);
663
664 r = select(mx + 1, &rset, &wset, 0, &tout);
665 if (r > 0)
666 {
667 if (FD_ISSET(m_iPipeFd[0], &rset))
668 {
669 flushPipe();
670 AVM_WRITE("ASF network reader", 1, "connect: interrupted\n");
671 r = -1;
672 }
673 break;
674 }
675 else if (r < 0)
676 {
677 AVM_WRITE("ASF network reader", "connect: select failed\n");
678 break;
679 }
680 else // r == 0
681 {
682 if (maxtry == 0)
683 {
684 AVM_WRITE("ASF network reader", "connect: timeout\n");
685 Locker locker(m_Mutex);
686 m_Cond.Broadcast();
687 }
688 continue;
689 }
690 }
691 if (r > 1)
692 {
693 socklen_t errlen = sizeof(int);
694 int err;
695 r = getsockopt(m_iSocket, SOL_SOCKET, SO_ERROR, &err, &errlen);
696 if (r < 0)
697 {
698 AVM_WRITE("ASF network reader", "connect: getsockopt failed %s\n", strerror(errno));
699 }
700 else if (err > 0)
701 {
702 AVM_WRITE("ASF network reader", "connect: error %s\n", strerror(err));
703 r = -1;
704 }
705 else
706 r = 0;
707 }
708 }
709 fcntl(m_iSocket, F_SETFL, oflg);
710 //printf("ENDLOOP %d %d\n", r, m_iSocket);
711 if (r < 0)
712 {
713 AVM_WRITE("ASF network reader", "Warning: connection failed ( %s )\n", strerror(errno));
714 close(m_iSocket);
715 m_iSocket = -1;
716 }
717 else
718 {
719 AVM_WRITE("ASF network reader", 1, "Socket created\n");
720 /*
721 char hostname[256];
722 if (gethostname(hostname, sizeof(hostname) - 1))
723 {
724 AVM_WRITE("ASF network reader", "WARNING: gethostname() failed ( %s )\n", strerror(errno));
725 hostname[sizeof(hostname) - 1]=0;
726 }
727 */
728 }
729 return m_iSocket;
730 }
731
732 ssize_t AsfNetworkInputStream::read(void* buffer, size_t size)
733 {
734 ssize_t result = 0;
735
736 while (!m_bQuit)
737 {
738 fd_set fset;
739 FD_ZERO(&fset);
740 FD_SET(m_iSocket, &fset);
741 FD_SET(m_iPipeFd[0], &fset);
742
743 struct timeval tout = { 20, 0}; // 20s timeout
744 int mx = (m_iSocket > m_iPipeFd[0]) ? m_iSocket : m_iPipeFd[0];
745
746 if (select(mx + 1, &fset, 0, 0, &tout) == 0)
747 {
748 AVM_WRITE("ASF network reader", "NetRead: TIMEOUTED\n");
749 Locker locker(m_Mutex);
750 m_Cond.Broadcast();
751 return -1;//continue;
752 }
753 //printf("socket %d %d\n", FD_ISSET(m_iPipeFd[0], &fset), FD_ISSET(m_iSocket, &fset));
754 if (FD_ISSET(m_iPipeFd[0], &fset))
755 {
756 flushPipe();
757 AVM_WRITE("ASF network reader", 1, "Interrupted\n");
758 return -1;
759 }
760 if (FD_ISSET(m_iSocket, &fset))
761 {
762 ssize_t tmp = ::read(m_iSocket, (char*)buffer + result, size - result);
763 //AVM_WRITE("ASF network reader", "NetRead: %d bytes (want: %d)\n", tmp, size-result);
764
765 if (tmp <= 0)
766 {
767 if (errno != EAGAIN && errno != EINTR)
768 {
769 if (errno)
770 AVM_WRITE("ASF network reader", "Aborting: read() returned %d ( %s )\n", errno, strerror(errno));
771 if (result>0)
772 return result;
773 if (tmp < 0)
774 AVM_WRITE("ASF network reader", "read() failed\n");
775 return tmp;
776 }
777 if (tmp == 0)
778 return 0;
779 continue;
780 }
781 result += tmp;
782 //printf("result %d:%d\n", result, size);
783 if (result >= (ssize_t) size)
784 {
785 if (l_iFd >= 0)
786 {
787 if (result > 32)
788 AVM_WRITE("ASF network reader", 1, "read(): returned %" PRIsz " of %" PRIsz " bytes\n", (size_t) result, size);
789 ::write(l_iFd, buffer, result);
790 fsync(l_iFd);
791 }
792 m_lReadBytes += result;
793 return result;
794 }
795 }
796 }
797 return -1;
798 }
799
800 ssize_t AsfNetworkInputStream::write(const void* b, size_t size)
801 {
802 const char* buffer = (const char*) b;
803 ssize_t wsize = size;
804 while (wsize > 0)
805 {
806 ssize_t i = ::write(m_iSocket, buffer, wsize);
807 if (i <= 0)
808 return i;
809 buffer += i;
810 wsize -= i;
811 }
812 return size;
813 }
814
815 ssize_t AsfNetworkInputStream::dwrite(const void* b, size_t size)
816 {
817 const char* buffer = (const char*) b;
818 if (m_lfd < 0)
819 {
820 if (m_lfd == -12345)
821 {
822 if (getenv("WRITE_ASF"))
823 {
824 // check if recording is requested
825 char tmpfilename[256];
826 char* tmpdir = getenv("TMPDIR");
827 strncpy(tmpfilename, (tmpdir) ? tmpdir : "/tmp", 240);
828 tmpfilename[240] = 0;
829 strcat(tmpfilename, "/asfXXXXXX");
830 m_lfd = mkstemp(tmpfilename);
831 AVM_WRITE("ASF network reader", "Writing ASF file: %s (%d)\n", tmpfilename, m_lfd);
832 }
833 else
834 {
835 AVM_WRITE("ASF network reader", "\n\n"
836 "\tIf you wish to store the stream into a local file\n"
837 "\tyou may try to use this before starting aviplay:\n"
838 "\t\texport WRITE_ASF=1\n"
839 "\tthis will create /tmp/asfXXXXX with received data\n\n");
840
841 m_lfd = -1;
842 }
843 }
844 if (m_lfd < 0)
845 return -1;
846 }
847 while (size > 0)
848 {
849 ssize_t i = ::write(m_lfd, buffer, size);
850 if (i < 0)
851 return i;
852 buffer += i;
853 size -= i;
854 }
855 fsync(m_lfd);
856 return 0;
857 }
858
859 int AsfNetworkInputStream::readContent()
860 {
861 m_bFinished = false;
862 int64_t rsize = 100000000;
863 int skip = 0;
864
865 while (!m_bQuit && !m_bFinished)
866 {
867 if (cacheSize() >= 1.)
868 {
869 AVM_WRITE("ASF network reader", 1, "FULLCACHE - wait for empty place\n");
870 char c;
871 fd_set fset;
872 FD_ZERO(&fset);
873 FD_SET(m_iPipeFd[0], &fset);
874 struct timeval tout = { 0, 1000000 };
875 if (select(m_iPipeFd[0] + 1, &fset, 0, 0, &tout) != 0)
876 {
877 if (FD_ISSET(m_iPipeFd[0], &fset))
878 {
879 ::read(m_iPipeFd[0], &c, 1);
880 AVM_WRITE("ASF network reader", 1, "read_content(): interrupted\n");
881 break;
882 }
883 }
884 continue;
885 }
886
887 if (m_Ctype == Plain)
888 {
889 // ugly trick for now - emulating streamed data
890 if (m_uiDataOffset > 0)
891 {
892 chhdr.size = (uint16_t)m_Header.max_pktsize;
893 chhdr.partflag = 0;
894 rsize -= chhdr.size;
895 //chhdr.kind = (rsize > 0) ? 0x4424 : 0x4524;
896 chhdr.kind = 0x4424;
897 }
898 else
899 {
900 // after the header the data header
901 // should follow
902 if (read(m_pBuffer, 24 + 26) < 0)
903 {
904 m_bFinished = true;
905 continue;
906 }
907 dwrite(m_pBuffer, 24 + 26);
908 GUID* guid = (GUID*) m_pBuffer;
909 avm_get_leGUID(guid);
910 if (guid_get_guidid(guid) == GUID_ASF_DATA)
911 {
912 rsize = avm_get_le64(m_pBuffer + 16) - 24;
913 // remember offset - so we are able to
914 // seek in Plain streams
915 m_uiDataOffset = m_lReadBytes;
916 }
917 }
918 }
919 else
920 {
921 if (read(&chhdr, sizeof(chhdr)) <= 0)
922 {
923 AVM_WRITE("ASF network reader", 1, "read() no more data\n");
924 break;
925 }
926 chhdr.le16();
927 //AVM_WRITE("ASF network reader", 1, "PACKET: 0x%x 0x%x 0x%x 0x%x 0x%x\n", chhdr.kind, chhdr.size, chhdr.seq, chhdr.tmp, chhdr.size_confirm);
928 if (chhdr.size < 8)
929 {
930 AVM_WRITE("ASF network reader", "I don't like chunk size: %d\n", chhdr.size);
931 break;
932 }
933 if (chhdr.size != chhdr.size_confirm)
934 {
935 AVM_WRITE("ASF network reader", "size != size_confirm (%d != %d)\n", chhdr.size, chhdr.size_confirm);
936 break;
937 }
938 chhdr.size = (uint16_t)(chhdr.size - 8);
939 }
940
941 AsfPacket* p;
942 unsigned short& size = chhdr.size;
943 //printf("STREAMPACKET 0x%x sz:%d %lld seq:%d part:%d sc:%d\n", chhdr.kind, size, rsize, chhdr.seq, chhdr.partflag, chhdr.size_confirm);
944 switch (chhdr.kind)
945 {
946 case 0x4824: // $H header
947 if (chhdr.partflag & 0x0400)
948 {
949 skip = read(m_pBuffer, chhdr.size);
950 if (skip < chhdr.size)
951 {
952 AVM_WRITE("ASF network reader", "wrong size (%d != %d)\n", skip, chhdr.size);
953 m_bFinished = true;
954 continue;
955 }
956 }
957 else if (skip > 0 && !(chhdr.partflag & 0x0800))
958 {
959 int r = read(m_pBuffer + skip, chhdr.size);
960 if (r < chhdr.size)
961 {
962 AVM_WRITE("ASF network reader", "wrong size (%d != %d)\n", r, chhdr.size);
963 m_bFinished = true;
964 continue;
965 }
966 skip += chhdr.size;
967 }
968 else
969 readHeader(skip + chhdr.size, skip);
970 break;
971 case 0x4424: // $D data
972 if (!m_bHeadersValid)
973 {
974 AVM_WRITE("ASF network reader", "unexpected data chunk (no headers yet)\n");
975 m_bFinished = true;
976 continue;
977 }
978 if (size > m_Header.max_pktsize)
979 {
980 AVM_WRITE("ASF network reader", "size>m_Header.max_pktsize (%d > %d) ignoring...\n", size, m_Header.max_pktsize);
981 continue;
982 }
983
984 //AVM_WRITE("ASF network reader", "Packet size %d\n", size);
985 p = new AsfPacket(m_Header.max_pktsize);
986 if (read(&(*p)[0], size) <= 0)
987 {
988 p->release();
989 AVM_WRITE("ASF network reader", "read() no more data\n");
990 m_bFinished = true;
991 continue;
992 }
993
994 //for (int i = 0; i < 20; i++)
995 // AVM_WRITE("ASF network reader", "%02x ",(uint_t) (*p)[inloaded + i]);
996 //AVM_WRITE("ASF network reader", "\n");
997 if (m_lfd >= 0 && size < m_Header.max_pktsize)
998 memset(&(*p)[size], 0, m_Header.max_pktsize - size); // zero padding
999 //AVM_WRITE("ASF network reader", 0, "Created packet %p %d - 0x%x (free %d : %.2f)\n", p, p->size(), (*p)[0], m_Header.max_pktsize - size, size/(float)m_Header.max_pktsize);
1000 if (p->init(m_uiTimeshift) == 0)
1001 {
1002 if (!m_uiTimeshift && m_Ctype == Live)
1003 {
1004 m_uiTimeshift = p->send_time - m_Header.preroll;
1005 p->fragments.clear();
1006 // reinit packet with new timeshift
1007 p->init(m_uiTimeshift);
1008 AVM_WRITE("ASF network reader", "setting timeshift %.3fs\n", m_uiTimeshift / 1000.);
1009 }
1010 dwrite(&(*p)[0], m_Header.max_pktsize);
1011 m_Mutex.Lock();
1012 //printf("Iterators: %d\n", m_Iterators.size());
1013 avm::vector<NetworkIterator*>::iterator it;
1014 for(it = m_Iterators.begin(); it != m_Iterators.end(); it++)
1015 {
1016 p->addRef();
1017 (*it)->m_Packets.push_back(p);
1018
1019 size_t psz = (*it)->m_Packets.size();
1020 //printf("PACKET SIZE %d time:%u\n", psz, p->send_time);
1021 if (psz >= 2 * CACHE_PACKETS && !(psz & 1))
1022 {
1023 uint_t i = 0;
1024 while (i + psz/2 < psz)
1025 {
1026 (*it)->m_Packets[i]->release();
1027 (*it)->m_Packets[i] = (*it)->m_Packets[i + psz/2];
1028 i++;
1029 }
1030 (*it)->m_Packets.resize(i);
1031 //AVM_WRITE("ASF network reader", "Removing unreaded packets %d\n", m_Iterators.size());
1032 }
1033 }
1034 m_Cond.Broadcast();
1035 m_Mutex.Unlock();
1036 }
1037
1038 p->release();
1039 break;
1040 case 0x4524: // $E
1041 m_bFinished = true;
1042 AVM_WRITE("ASF network reader", "read_content(): finished transmission\n");
1043 break;
1044 } //switch
1045 }
1046
1047 if (m_lfd>=0) close(m_lfd);
1048 m_lfd = -1;
1049
1050 m_Mutex.Lock();
1051 for(avm::vector<NetworkIterator*>::iterator it2 = m_Iterators.begin();
1052 it2 != m_Iterators.end(); it2++)
1053 (*it2)->setEof(true);
1054 //not here m_Cond.Broadcast();
1055 m_Mutex.Unlock();
1056
1057 if (m_bFinished)
1058 return 0;
1059
1060 m_bFinished = true;
1061 return -1;
1062 }
1063
1064 AsfNetworkInputStream::Content AsfNetworkInputStream::checkContent(const char* request)
1065 {
1066 int hdrpos = 0;
1067 uint_t linepos = 0;
1068 uint_t linenum = 0;
1069 char *hdrptr;
1070 // Platform for Privacy Preferences (p3p)
1071 // http://www.w3.org/P3P/
1072 bool eol = false;
1073 char HTTPLine[1024];
1074 char Features[256];
1075 char ContentType[256];
1076
1077 ContentType[0] = 0;
1078 Features[0] = 0;
1079
1080 // send http request
1081 write(request, strlen(request));
1082 //AVM_WRITE("ASF network reader", "WRITE %s\n", request);
1083
1084 for (;;)
1085 {
1086 char c;
1087 if (read(&c, 1) <= 0)
1088 // header was incorrect
1089 // this is probably the best we could do
1090 return Unknown;
1091
1092 // \r\n means http header eof
1093 if (linepos < (sizeof(HTTPLine) - 1)
1094 && (c != '\r') && (c != '\n'))
1095 {
1096 eol = false;
1097 // all letter in lowercase
1098 HTTPLine[linepos++] = (char) tolower(c);
1099 }
1100 else
1101 HTTPLine[linepos] = 0;
1102
1103 if (c == '\n')
1104 {
1105 if (eol)
1106 break; // header eof
1107
1108 linepos = 0;
1109 eol = true;
1110 linenum++;
1111 hdrptr = HTTPLine;
1112
1113 //printf("PARSEHTTP: %s\n",hdrptr);
1114 /* Parse first line of HTTP reply */
1115 if (linenum == 1)
1116 {
1117 if (!strncmp(hdrptr, "http/1.0 ", 9)
1118 || !strncmp(hdrptr, "http/1.1 ", 9))
1119 {
1120 int errorcode = 0;
1121 hdrptr += 9;
1122 sscanf(hdrptr, "%d", &errorcode);
1123 hdrptr += 4;
1124 if (strstr(hdrptr, "redirect")
1125 || strstr(hdrptr, "object moved"))
1126 {
1127 m_iRedirectSize = 4096;
1128 return Redirect;
1129 }
1130 if (strstr(hdrptr, "bad request"))
1131 return Unknown;
1132 }
1133 else
1134 {
1135 AVM_WRITE("ASF network reader", "Illegal server reply! Expected HTTP/1.0 or HTTP/1.1\n");
1136 }
1137 }
1138 else
1139 {
1140 /* parse all other lines of HTTP reply */
1141 if (!strncmp(hdrptr, "content-type: ", 14))
1142 {
1143 strncpy(ContentType, hdrptr + 14, sizeof(ContentType));
1144 }
1145 else if (!strncmp(hdrptr, "content-length: ", 16))
1146 {
1147 m_iRedirectSize = atoi(hdrptr + 16);
1148 AVM_WRITE("ASF network reader", 1, "Content-Length: %d\n", m_iRedirectSize);
1149 }
1150 else if (!strncmp(hdrptr, "pragma: ", 8))
1151 {
1152 char* f = strstr(hdrptr + 8, "features=");
1153 if (f)
1154 strncpy(Features, f + 9, sizeof(Features));
1155 }
1156 else if (!strncmp(hdrptr, "accept-ranges: bytes", 20))
1157 m_bAcceptRanges = true;
1158 }
1159 }
1160 }
1161
1162 // ok here it is a bit tricky
1163 // many servers seems to be passing here false headers
1164 // were they claim they are redirectors while they
1165 // are already giving us a stream
1166 // so we try to read some more data from the connection
1167 // but only in case we have not yet decided type of stream
1168 // as we could get here for the Plain seek again
1169 // FIXME
1170 m_lReadBytes = 0;
1171 if ((m_Ctype == Unknown) && (m_iReadSize = read(m_pBuffer, sizeof(chhdr))) > 0)
1172 {
1173 memcpy(&chhdr, m_pBuffer, m_iReadSize);
1174 chhdr.le16();
1175 chhdr.size = (uint16_t)(chhdr.size - 8);
1176 //printf("PACKET sz:%d se:%d un:%d sc:%d\n", chhdr.size, chhdr.seq, chhdr.partflag, chhdr.size_confirm);
1177 if (chhdr.kind == 0x4824) // $H
1178 {
1179 int hsize = chhdr.size;
1180 int skip = 0;
1181
1182 if (chhdr.partflag & 0x0400)
1183 while (chhdr.kind == 0x4824)
1184 {
1185 if (chhdr.partflag & 0x0400)
1186 {
1187 // reset
1188 skip = 0;
1189 hsize = 0;
1190 }
1191 hsize += chhdr.size;
1192 if (chhdr.partflag & 0x0800)
1193 break; // header packet complete
1194 int r = read(m_pBuffer + skip, chhdr.size);
1195 if (r < 0)
1196 break;
1197 skip += r;
1198 read(&chhdr, sizeof(chhdr));
1199 chhdr.le16();
1200 chhdr.size = (uint16_t)(chhdr.size - 8);
1201 }
1202 readHeader(hsize, skip);
1203 }
1204 else
1205 {
1206 if (avm_get_le32(m_pBuffer) == 0x75b22630) // guid_asf_header
1207 {
1208 m_Ctype = Plain;
1209 readHeader(16 + 8, m_iReadSize);
1210 // if this is the ASF header -> no socket reopen
1211 }
1212 }
1213 }
1214
1215 /* Determine whether this is live content or not */
1216 if (!strcmp(ContentType, "application/octet-stream")
1217 || !strcasecmp(ContentType, "application/vnd.ms.wms-hdr.asfv1")
1218 || !strcasecmp(ContentType, "application/x-mms-framed"))
1219 {
1220 if (!m_bHeadersValid) return Redirect;
1221 return (strstr(Features, "broadcast")) ? Live : Prerecorded;
1222 }
1223
1224 if ((m_bHeadersValid && m_Ctype == Plain)
1225 || !strcmp(ContentType, "text/plain"))
1226 // if the redirector's size is small it's not a plain file
1227 return (m_iRedirectSize < 300) ? Redirect : Plain;
1228
1229 if ((!strcmp(ContentType, "text/html"))
1230 || (!strcmp(ContentType, "audio/x-ms-wax"))
1231 || (!strcmp(ContentType, "audio/x-ms-wma"))
1232 || (!strcmp(ContentType, "video/s-ms-asf"))
1233 || (!strcmp(ContentType, "video/x-ms-afs"))
1234 || (!strcmp(ContentType, "video/x-ms-asf"))
1235 || (!strcmp(ContentType, "video/x-ms-wma"))
1236 || (!strcmp(ContentType, "video/x-ms-wmv"))
1237 || (!strcmp(ContentType, "video/x-ms-wmx"))
1238 || (!strcmp(ContentType, "video/x-ms-wvx"))
1239 || (!strcmp(ContentType, "video/x-msvideo")))
1240 return Redirect;
1241
1242 return Unknown;
1243 }
1244
1245 void AsfNetworkInputStream::readHeader(size_t size, size_t skip)
1246 {
1247 AVM_WRITE("ASF network reader", "read hdrbl %" PRIsz " skip: %" PRIsz "\n", size, skip);
1248 ssize_t r = read(m_pBuffer + skip, size - skip);
1249 if (r < 0)
1250 return;
1251
1252 // check if this is really asf header
1253 GUID guid = *(GUID*) m_pBuffer;
1254 avm_get_leGUID(&guid);
1255 if (guid_get_guidid(&guid) != GUID_ASF_HEADER)
1256 return; // let's just ignore this junk
1257 if (size == 24) // read the header (trick used for Plain)
1258 {
1259 int64_t hsz = avm_get_le64(m_pBuffer + 16) - 24;
1260 read(m_pBuffer + 24, hsz);
1261 size += hsz;
1262 skip = 0;
1263 }
1264 else
1265 r += skip;
1266
1267 size = avm_get_le64(m_pBuffer + 16);
1268 if (!m_bHeadersValid)
1269 // first time header + data size beging (50 bytes)
1270 // should come right after header
1271 dwrite(m_pBuffer, size + 50);
1272
1273 //printf("SIZE %d %d\n", size, r);
1274 m_Mutex.Lock();
1275 m_bHeadersValid = parseHeader((uint8_t*)m_pBuffer + 24, size - 24,
1276 m_bHeadersValid ? 1 : 0);
1277 if (m_bHeadersValid)
1278 AVM_WRITE("ASF network reader", "received valid headers\n");
1279 m_Cond.Broadcast();
1280 m_Mutex.Unlock();
1281 }
1282
1283 int AsfNetworkInputStream::readRedirect()
1284 {
1285 if (m_iRedirectSize > 65536)
1286 {
1287 AVM_WRITE("ASF network reader", "Redirector size too large! (%d)\n", m_iRedirectSize);
1288 m_iRedirectSize = 65536;
1289 }
1290
1291 while (m_iReadSize < m_iRedirectSize
1292 && read(&m_pBuffer[m_iReadSize], 1) > 0)
1293 m_iReadSize++;
1294
1295 ASXReader* r = new ASXReader(m_Server, m_Filename);
1296 if (!r->create(m_pBuffer, m_iReadSize))
1297 {
1298 AVM_WRITE("ASF network reader", "No redirector found\n");
1299 delete r;
1300 return -1;
1301 }
1302 else
1303 m_pReader = r;
1304 return 0;
1305 }
1306
1307 bool AsfNetworkInputStream::getURLs(avm::vector<avm::string>& urls)
1308 {
1309 return (m_pReader) ? m_pReader->getURLs(urls) : false;
1310 }
1311
1312 AsfIterator* AsfNetworkInputStream::getIterator(uint_t id)
1313 {
1314 //AVM_WRITE("ASF network reader", "GETITERATOR %d\n", id);
1315 if (id >= m_Streams.size())
1316 return 0;
1317 m_Iterators.push_back(new NetworkIterator(this, m_Streams[id].hdr.stream & 0x7f));
1318 AsfIterator* it = m_Iterators.back();
1319 it->addRef();
1320 return it;
1321 }
1322
1323 /*
1324 * replace specific characters in the URL string by an escape sequence
1325 */
1326 void URLString::escape()
1327 {
1328 char* nstr = new char[size() * 3 + 1];
1329 char* outbuf = nstr;
1330 const char* inbuf = c_str();
1331 unsigned char c;
1332 do
1333 {
1334 /* mark characters do not touch escape character */
1335 /* reserved characters see RFC 2396 */
1336 const char avoid[] = "#`'<>[]^|\\\"";
1337 c = *inbuf++;
1338 if (c && (c <= ' ' || strchr(avoid, c)))
1339 {
1340 /* these character should be escaped */
1341 unsigned char c1 = (c >> 4) & 0x0f;
1342 unsigned char c2 = (unsigned char) (c & 0x0f);
1343 *outbuf++ = '%';
1344 *outbuf++ = c1 + (c1 < 10) ? '0' : 'A';
1345 *outbuf++ = c2 + (c2 < 10) ? '0' : 'A';
1346 }
1347 else
1348 *outbuf++ = c;
1349 } while (c);
1350
1351 //printf("Before: %s\nAfter: %s\n", str, n);
1352 string::operator=(nstr);
1353 delete nstr;
1354 }
1355
1356 AVM_END_NAMESPACE;