llpipeutil.cpp
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:4k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llpipeutil.cpp
  3.  * @date 2006-05-18
  4.  * @brief Utility pipe fittings for injecting and extracting strings
  5.  *
  6.  * $LicenseInfo:firstyear=2006&license=viewergpl$
  7.  * 
  8.  * Copyright (c) 2006-2010, Linden Research, Inc.
  9.  * 
  10.  * Second Life Viewer Source Code
  11.  * The source code in this file ("Source Code") is provided by Linden Lab
  12.  * to you under the terms of the GNU General Public License, version 2.0
  13.  * ("GPL"), unless you have obtained a separate licensing agreement
  14.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  15.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  16.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  17.  * 
  18.  * There are special exceptions to the terms and conditions of the GPL as
  19.  * it is applied to this Source Code. View the full text of the exception
  20.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  21.  * online at
  22.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  23.  * 
  24.  * By copying, modifying or distributing this software, you acknowledge
  25.  * that you have read and understood your obligations described above,
  26.  * and agree to abide by those obligations.
  27.  * 
  28.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  29.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  30.  * COMPLETENESS OR PERFORMANCE.
  31.  * $/LicenseInfo$
  32.  */
  33. #include "linden_common.h"
  34. #include "llpipeutil.h"
  35. #include <stdlib.h>
  36. #include <sstream>
  37. #include "llbufferstream.h"
  38. #include "lldefs.h"
  39. #include "llframetimer.h"
  40. #include "llpumpio.h"
  41. #include "llrand.h"
  42. #include "lltimer.h"
  43. F32 pump_loop(LLPumpIO* pump, F32 seconds)
  44. {
  45. LLTimer timer;
  46. timer.setTimerExpirySec(seconds);
  47. while(!timer.hasExpired())
  48. {
  49. LLFrameTimer::updateFrameTime();
  50. pump->pump();
  51. pump->callback();
  52. }
  53. return timer.getElapsedTimeF32();
  54. }
  55. //virtual 
  56. LLIOPipe::EStatus LLPipeStringInjector::process_impl(
  57. const LLChannelDescriptors& channels,
  58. buffer_ptr_t& buffer,
  59. bool& eos,
  60. LLSD& context,
  61. LLPumpIO* pump)
  62. {
  63. buffer->append(channels.out(), (U8*) mString.data(), mString.size());
  64. eos = true;
  65. return STATUS_DONE;
  66. }
  67. LLIOPipe::EStatus LLPipeStringExtractor::process_impl(
  68. const LLChannelDescriptors& channels,
  69.     buffer_ptr_t& buffer,
  70.     bool& eos,
  71.     LLSD& context,
  72.     LLPumpIO* pump)
  73. {
  74.     if(!eos) return STATUS_BREAK;
  75.     if(!pump || !buffer) return STATUS_PRECONDITION_NOT_MET;
  76. LLBufferStream istr(channels, buffer.get());
  77. std::ostringstream ostr;
  78. while (istr.good())
  79. {
  80. char buf[1024]; /* Flawfinder: ignore */
  81. istr.read(buf, sizeof(buf)); /* Flawfinder: ignore */
  82. ostr.write(buf, istr.gcount());
  83. }
  84. mString = ostr.str();
  85. mDone = true;
  86. return STATUS_DONE;
  87. }
  88. // virtual
  89. LLIOPipe::EStatus LLIOFuzz::process_impl(
  90. const LLChannelDescriptors& channels,
  91. buffer_ptr_t& buffer,
  92. bool& eos,
  93. LLSD& context,
  94. LLPumpIO* pump)
  95. {
  96. while(mByteCount)
  97. {
  98. std::vector<U8> data;
  99. data.reserve(10000);
  100. int size = llmin(10000, mByteCount);
  101. std::generate_n(
  102. std::back_insert_iterator< std::vector<U8> >(data),
  103. size,
  104. rand);
  105. buffer->append(channels.out(), &data[0], size);
  106. mByteCount -= size;
  107. }
  108. return STATUS_OK;
  109. }
  110. struct random_ascii_generator
  111. {
  112. random_ascii_generator() {}
  113. U8 operator()()
  114. {
  115. int rv = rand();
  116. rv %= (127 - 32);
  117. rv += 32;
  118. return rv;
  119. }
  120. };
  121. // virtual
  122. LLIOPipe::EStatus LLIOASCIIFuzz::process_impl(
  123. const LLChannelDescriptors& channels,
  124. buffer_ptr_t& buffer,
  125. bool& eos,
  126. LLSD& context,
  127. LLPumpIO* pump)
  128. {
  129. while(mByteCount)
  130. {
  131. std::vector<U8> data;
  132. data.reserve(10000);
  133. int size = llmin(10000, mByteCount);
  134. std::generate_n(
  135. std::back_insert_iterator< std::vector<U8> >(data),
  136. size,
  137. random_ascii_generator());
  138. buffer->append(channels.out(), &data[0], size);
  139. mByteCount -= size;
  140. }
  141. return STATUS_OK;
  142. }
  143. // virtual
  144. LLIOPipe::EStatus LLIONull::process_impl(
  145. const LLChannelDescriptors& channels,
  146. buffer_ptr_t& buffer,
  147. bool& eos,
  148. LLSD& context,
  149. LLPumpIO* pump)
  150. {
  151. return STATUS_OK;
  152. }
  153. // virtual
  154. LLIOPipe::EStatus LLIOSleeper::process_impl(
  155. const LLChannelDescriptors& channels,
  156. buffer_ptr_t& buffer,
  157. bool& eos,
  158. LLSD& context,
  159. LLPumpIO* pump)
  160. {
  161. if(!mRespond)
  162. {
  163. lldebugs << "LLIOSleeper::process_impl() sleeping." << llendl;
  164. mRespond = true;
  165. static const F64 SLEEP_TIME = 2.0;
  166. pump->sleepChain(SLEEP_TIME);
  167. return STATUS_BREAK;
  168. }
  169. lldebugs << "LLIOSleeper::process_impl() responding." << llendl;
  170. LLBufferStream ostr(channels, buffer.get());
  171. ostr << "huh? sorry, I was sleeping." << std::endl;
  172. return STATUS_DONE;
  173. }