正在显示
1 个修改的文件
包含
355 行增加
和
0 行删除
src/server/spserver/spsession.cpp
0 → 100644
1 | +/* | |
2 | + * Copyright 2007-2008 Stephen Liu | |
3 | + * For license terms, see the file COPYING along with this library. | |
4 | + */ | |
5 | + | |
6 | +#include <sys/types.h> | |
7 | +#include <stdio.h> | |
8 | +#include <stdlib.h> | |
9 | +#include <string.h> | |
10 | +#include <assert.h> | |
11 | + | |
12 | +#include "spporting.hpp" | |
13 | + | |
14 | +#include "spsession.hpp" | |
15 | +#include "sphandler.hpp" | |
16 | +#include "spbuffer.hpp" | |
17 | +#include "sputils.hpp" | |
18 | +#include "sprequest.hpp" | |
19 | +#include "spiochannel.hpp" | |
20 | + | |
21 | +#ifndef WIN32 | |
22 | +#include "event.h" | |
23 | +#endif | |
24 | + | |
25 | +//------------------------------------------------------------------- | |
26 | + | |
27 | +typedef struct tagSP_SessionEntry { | |
28 | + uint16_t mSeq; | |
29 | + uint16_t mNext; | |
30 | + | |
31 | + SP_Session * mSession; | |
32 | +} SP_SessionEntry; | |
33 | + | |
34 | +SP_SessionManager :: SP_SessionManager() | |
35 | +{ | |
36 | + mFreeCount = 0; | |
37 | + mFreeList = 0; | |
38 | + mCount = 0; | |
39 | + memset( mArray, 0, sizeof( mArray ) ); | |
40 | +} | |
41 | + | |
42 | +SP_SessionManager :: ~SP_SessionManager() | |
43 | +{ | |
44 | + for( int i = 0; i < (int)( sizeof( mArray ) / sizeof( mArray[0] ) ); i++ ) { | |
45 | + SP_SessionEntry_t * list = mArray[ i ]; | |
46 | + if( NULL != list ) { | |
47 | + SP_SessionEntry_t * iter = list; | |
48 | + for( int i = 0; i < eColPerRow; i++, iter++ ) { | |
49 | + if( NULL != iter->mSession ) { | |
50 | + delete iter->mSession; | |
51 | + iter->mSession = NULL; | |
52 | + } | |
53 | + } | |
54 | + free( list ); | |
55 | + } | |
56 | + } | |
57 | + | |
58 | + memset( mArray, 0, sizeof( mArray ) ); | |
59 | +} | |
60 | + | |
61 | +uint16_t SP_SessionManager :: allocKey( uint16_t * seq ) | |
62 | +{ | |
63 | + uint16_t key = 0; | |
64 | + | |
65 | + if( mFreeList <= 0 ) { | |
66 | + int avail = -1; | |
67 | + for( int i = 1; i < (int)( sizeof( mArray ) / sizeof( mArray[0] ) ); i++ ) { | |
68 | + if( NULL == mArray[i] ) { | |
69 | + avail = i; | |
70 | + break; | |
71 | + } | |
72 | + } | |
73 | + | |
74 | + if( avail > 0 ) { | |
75 | + mFreeCount += eColPerRow; | |
76 | + mArray[ avail ] = ( SP_SessionEntry_t * )calloc( | |
77 | + eColPerRow, sizeof( SP_SessionEntry_t ) ); | |
78 | + for( int i = eColPerRow - 1; i >= 0; i-- ) { | |
79 | + mArray[ avail ] [ i ].mNext = mFreeList; | |
80 | + mFreeList = eColPerRow * avail + i; | |
81 | + } | |
82 | + } | |
83 | + } | |
84 | + | |
85 | + if( mFreeList > 0 ) { | |
86 | + key = mFreeList; | |
87 | + --mFreeCount; | |
88 | + | |
89 | + int row = mFreeList / eColPerRow, col = mFreeList % eColPerRow; | |
90 | + | |
91 | + *seq = mArray[ row ] [ col ].mSeq; | |
92 | + mFreeList = mArray[ row ] [ col ].mNext; | |
93 | + } | |
94 | + | |
95 | + return key; | |
96 | +} | |
97 | + | |
98 | +int SP_SessionManager :: getCount() | |
99 | +{ | |
100 | + return mCount; | |
101 | +} | |
102 | + | |
103 | +int SP_SessionManager :: getFreeCount() | |
104 | +{ | |
105 | + return mFreeCount; | |
106 | +} | |
107 | + | |
108 | +void SP_SessionManager :: put( uint16_t key, uint16_t seq, SP_Session * session ) | |
109 | +{ | |
110 | + int row = key / eColPerRow, col = key % eColPerRow; | |
111 | + | |
112 | + assert( NULL != mArray[ row ] ); | |
113 | + | |
114 | + SP_SessionEntry_t * list = mArray[ row ]; | |
115 | + | |
116 | + assert( NULL == list[ col ].mSession ); | |
117 | + assert( seq == list[ col ].mSeq ); | |
118 | + | |
119 | + list[ col ].mSession = session; | |
120 | + | |
121 | + mCount++; | |
122 | +} | |
123 | + | |
124 | +SP_Session * SP_SessionManager :: get( uint16_t key, uint16_t * seq ) | |
125 | +{ | |
126 | + int row = key / eColPerRow, col = key % eColPerRow; | |
127 | + | |
128 | + SP_Session * ret = NULL; | |
129 | + | |
130 | + SP_SessionEntry_t * list = mArray[ row ]; | |
131 | + if( NULL != list ) { | |
132 | + ret = list[ col ].mSession; | |
133 | + * seq = list[ col ].mSeq; | |
134 | + } else { | |
135 | + * seq = 0; | |
136 | + } | |
137 | + | |
138 | + return ret; | |
139 | +} | |
140 | + | |
141 | +SP_Session * SP_SessionManager :: remove( uint16_t key, uint16_t seq ) | |
142 | +{ | |
143 | + int row = key / eColPerRow, col = key % eColPerRow; | |
144 | + | |
145 | + SP_Session * ret = NULL; | |
146 | + | |
147 | + SP_SessionEntry_t * list = mArray[ row ]; | |
148 | + if( NULL != list ) { | |
149 | + assert( seq == list[ col ].mSeq ); | |
150 | + | |
151 | + ret = list[ col ].mSession; | |
152 | + | |
153 | + list[ col ].mSession = NULL; | |
154 | + list[ col ].mSeq++; | |
155 | + | |
156 | + list[ col ].mNext = mFreeList; | |
157 | + mFreeList = key; | |
158 | + ++mFreeCount; | |
159 | + | |
160 | + mCount--; | |
161 | + } | |
162 | + | |
163 | + return ret; | |
164 | +} | |
165 | + | |
166 | +//------------------------------------------------------------------- | |
167 | + | |
168 | +SP_Session :: SP_Session( SP_Sid_t sid ) | |
169 | +{ | |
170 | + mSid = sid; | |
171 | + | |
172 | + mReadEvent = NULL; | |
173 | + mWriteEvent = NULL; | |
174 | + | |
175 | +#ifndef WIN32 | |
176 | + mReadEvent = (struct event*)malloc( sizeof( struct event ) ); | |
177 | + mWriteEvent = (struct event*)malloc( sizeof( struct event ) ); | |
178 | +#endif | |
179 | + | |
180 | + mHandler = NULL; | |
181 | + mArg = NULL; | |
182 | + | |
183 | + mInBuffer = new SP_Buffer(); | |
184 | + mRequest = new SP_Request(); | |
185 | + | |
186 | + mOutOffset = 0; | |
187 | + mOutList = new SP_ArrayList(); | |
188 | + | |
189 | + mStatus = eNormal; | |
190 | + mRunning = 0; | |
191 | + mWriting = 0; | |
192 | + mReading = 0; | |
193 | + | |
194 | + mTotalRead = mTotalWrite = 0; | |
195 | + | |
196 | + mIOChannel = NULL; | |
197 | +} | |
198 | + | |
199 | +SP_Session :: ~SP_Session() | |
200 | +{ | |
201 | + if( NULL != mReadEvent ) free( mReadEvent ); | |
202 | + mReadEvent = NULL; | |
203 | + | |
204 | + if( NULL != mWriteEvent ) free( mWriteEvent ); | |
205 | + mWriteEvent = NULL; | |
206 | + | |
207 | + if( NULL != mHandler ) { | |
208 | + delete mHandler; | |
209 | + mHandler = NULL; | |
210 | + } | |
211 | + | |
212 | + delete mRequest; | |
213 | + mRequest = NULL; | |
214 | + | |
215 | + delete mInBuffer; | |
216 | + mInBuffer = NULL; | |
217 | + | |
218 | + delete mOutList; | |
219 | + mOutList = NULL; | |
220 | + | |
221 | + if( NULL != mIOChannel ) { | |
222 | + delete mIOChannel; | |
223 | + mIOChannel = NULL; | |
224 | + } | |
225 | +} | |
226 | + | |
227 | +struct event * SP_Session :: getReadEvent() | |
228 | +{ | |
229 | + return mReadEvent; | |
230 | +} | |
231 | + | |
232 | +struct event * SP_Session :: getWriteEvent() | |
233 | +{ | |
234 | + return mWriteEvent; | |
235 | +} | |
236 | + | |
237 | +void SP_Session :: setHandler( SP_Handler * handler ) | |
238 | +{ | |
239 | + mHandler = handler; | |
240 | +} | |
241 | + | |
242 | +SP_Handler * SP_Session :: getHandler() | |
243 | +{ | |
244 | + return mHandler; | |
245 | +} | |
246 | + | |
247 | +void SP_Session :: setArg( void * arg ) | |
248 | +{ | |
249 | + mArg = arg; | |
250 | +} | |
251 | + | |
252 | +void * SP_Session :: getArg() | |
253 | +{ | |
254 | + return mArg; | |
255 | +} | |
256 | + | |
257 | +SP_Sid_t SP_Session :: getSid() | |
258 | +{ | |
259 | + return mSid; | |
260 | +} | |
261 | + | |
262 | +SP_Buffer * SP_Session :: getInBuffer() | |
263 | +{ | |
264 | + return mInBuffer; | |
265 | +} | |
266 | + | |
267 | +SP_Request * SP_Session :: getRequest() | |
268 | +{ | |
269 | + return mRequest; | |
270 | +} | |
271 | + | |
272 | +void SP_Session :: setOutOffset( int offset ) | |
273 | +{ | |
274 | + mOutOffset = offset; | |
275 | +} | |
276 | + | |
277 | +int SP_Session :: getOutOffset() | |
278 | +{ | |
279 | + return mOutOffset; | |
280 | +} | |
281 | + | |
282 | +SP_ArrayList * SP_Session :: getOutList() | |
283 | +{ | |
284 | + return mOutList; | |
285 | +} | |
286 | + | |
287 | +void SP_Session :: setStatus( int status ) | |
288 | +{ | |
289 | + mStatus = status; | |
290 | +} | |
291 | + | |
292 | +int SP_Session :: getStatus() | |
293 | +{ | |
294 | + return mStatus; | |
295 | +} | |
296 | + | |
297 | +int SP_Session :: getRunning() | |
298 | +{ | |
299 | + return mRunning; | |
300 | +} | |
301 | + | |
302 | +void SP_Session :: setRunning( int running ) | |
303 | +{ | |
304 | + mRunning = running; | |
305 | +} | |
306 | + | |
307 | +int SP_Session :: getWriting() | |
308 | +{ | |
309 | + return mWriting; | |
310 | +} | |
311 | + | |
312 | +void SP_Session :: setWriting( int writing ) | |
313 | +{ | |
314 | + mWriting = writing; | |
315 | +} | |
316 | + | |
317 | +int SP_Session :: getReading() | |
318 | +{ | |
319 | + return mReading; | |
320 | +} | |
321 | + | |
322 | +void SP_Session :: setReading( int reading ) | |
323 | +{ | |
324 | + mReading = reading; | |
325 | +} | |
326 | + | |
327 | +SP_IOChannel * SP_Session :: getIOChannel() | |
328 | +{ | |
329 | + return mIOChannel; | |
330 | +} | |
331 | + | |
332 | +void SP_Session :: setIOChannel( SP_IOChannel * ioChannel ) | |
333 | +{ | |
334 | + mIOChannel = ioChannel; | |
335 | +} | |
336 | + | |
337 | +unsigned int SP_Session :: getTotalRead() | |
338 | +{ | |
339 | + return mTotalRead; | |
340 | +} | |
341 | + | |
342 | +void SP_Session :: addRead( int len ) | |
343 | +{ | |
344 | + mTotalRead += len; | |
345 | +} | |
346 | + | |
347 | +unsigned int SP_Session :: getTotalWrite() | |
348 | +{ | |
349 | + return mTotalWrite; | |
350 | +} | |
351 | + | |
352 | +void SP_Session :: addWrite( int len ) | |
353 | +{ | |
354 | + mTotalWrite += len; | |
355 | +} | ... | ... |
请
注册
或
登录
后发表评论