00001
00002
00003
00004 #include "Platform.h"
00005 #include "Declarations.h"
00006 #include <stdio.h>
00007 #include <stdlib.h>
00008 #include <assert.h>
00009
00010
00011
00012
00013 #include "Message.h"
00014 #include "PacketQueue.h"
00015 #include "ResponseWaitQueue.h"
00016 #include "MessageBuffers.h"
00017 #include "PeerList.h"
00018 #include "NetworkQueue.h"
00019
00020 #ifdef __NEED_SOCKET_FUNCTIONS_SW__
00021
00022
00023 #if defined(PLF_UNIX_TCPIPSTACK) || defined(PLF_LWIP_TCPIPSTACK)
00024
00025 const INT32 SOCKET_ERROR = -1;
00026 const INT32 INVALID_SOCKET = -1;
00027 #endif
00028
00029 #ifdef PLF_NICHE_TCPIPSTACK
00030 #define NICHE_SO_SENDBUF_SIZE 4096
00031 #define NICHE_SO_RECVBUF_SIZE 8192
00032 #endif
00033
00034
00035 const INT32 platformMaxFdSets = PLF_MAX_FDSETS;
00036
00037
00038
00039 ONECHAR *platformIPAddrConvert( const UINT32 ip_hostorder )
00040 {
00041 static char buffer[16];
00042 UINT32 networkorder = htonl(ip_hostorder);
00043 unsigned char *b = (unsigned char *) &networkorder;
00044
00045 sprintf(buffer, "%d.%d.%d.%d", b[0], b[1], b[2], b[3]);
00046
00047 return (ONECHAR *) buffer;
00048 }
00049
00050
00051
00052
00053 UINT32 platformIPAddrConvert( const ONECHAR *ip_addr_dotted_string)
00054 {
00055
00056
00057 INT32 ip1, ip2, ip3, ip4;
00058 UINT32 ip_addr;
00059
00060 int ret = sscanf((const char *) ip_addr_dotted_string, "%d.%d.%d.%d", &ip1, &ip2, &ip3, &ip4);
00061 ret = 1;
00062
00063 if (ip1 < 0 || ip1 > 255) return INADDR_NONE;
00064 if (ip2 < 0 || ip2 > 255) return INADDR_NONE;
00065 if (ip2 < 0 || ip2 > 255) return INADDR_NONE;
00066 if (ip2 < 0 || ip2 > 255) return INADDR_NONE;
00067
00068 #ifndef PLF_ENDIANCHANGE
00069 ip_addr = (ip1&0xff) + ((ip2&0xff)<<8) + ((ip3&0xff)<<16) + ((((UINT32)ip4)&0xff)<<24);
00070 #else
00071 ip_addr = (ip4&0xff) + ((ip3&0xff)<<8) + ((ip2&0xff)<<16) + ((((UINT32)ip1)&0xff)<<24);
00072 #endif
00073
00074 return ip_addr;
00075 }
00076
00077 void platformInitializeSocketSubsystem()
00078 {
00079 #ifdef PLF_WINNT_TCPIPSTACK
00080 WSADATA wsad;
00081
00082 int ret = WSAStartup( 0x0202, &wsad);
00083 if (ret != 0) assert( 1==2 );
00084 #endif
00085 }
00086
00087 void platformDeinitializeSocketSubsystem()
00088 {
00089 #ifdef PLF_WINNT_TCPIPSTACK
00090 WSACleanup();
00091 #endif
00092 }
00093
00094
00108 socktype platformSocketCreateInet( INT32 type )
00109 {
00110 #ifdef PLF_UNIX_TCPIPSTACK
00111 return( socket( PF_INET, type, 0 ) );
00112 #endif
00113
00114 #ifdef PLF_LWIP_TCPIPSTACK
00115 return( lwip_socket( PF_INET, type, 0 ) );
00116 #endif
00117
00118 #ifdef PLF_WINNT_TCPIPSTACK
00119 socktype sockret;
00120 int cc1,cc2;
00121 int optval;
00122
00123 sockret = socket( AF_INET, type, 0 );
00124
00125 if (sockret == INVALID_SOCKET) return INVALID_SOCKET;
00126
00127 optval = SO_RECVBUF_SIZE;
00128 cc1 = setsockopt(sockret,SOL_SOCKET,SO_RCVBUF,(const char *)&optval,sizeof(int));
00129
00130 optval = SO_SENDBUF_SIZE;
00131 cc2 = setsockopt(sockret,SOL_SOCKET,SO_SNDBUF,(const char *)&optval,sizeof(int));
00132
00133 if (cc1 != 0 || cc2 != 0)
00134 {
00135 closesocket( sockret );
00136 return INVALID_SOCKET;
00137 }
00138
00139 return sockret;
00140 #endif
00141
00142 #ifdef PLF_NICHE_TCPIPSTACK
00143 socktype sockret;
00144 int cc1,cc2;
00145 int optval;
00146
00147 sockret = bsd_socket( PF_INET, type, 0 );
00148
00149 if (sockret == INVALID_SOCKET) return INVALID_SOCKET;
00150
00151 optval = NICHE_SO_RECVBUF_SIZE;
00152 cc1 = t_setsockopt(sockret,SOL_SOCKET,SO_RCVBUF,(void *)&optval,sizeof(int));
00153
00154 optval = NICHE_SO_SENDBUF_SIZE;
00155 cc2 = t_setsockopt(sockret,SOL_SOCKET,SO_SNDBUF,(void*)&optval,sizeof(int));
00156
00157 if (cc1 != 0 || cc2 != 0)
00158 {
00159 bsd_close( sockret );
00160 return INVALID_SOCKET;
00161 }
00162
00163 return sockret;
00164 #endif
00165 }
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182 INT32 platformSocketConnect(socktype s, const struct sockaddr * Saddr, size_t size_sockaddr)
00183 {
00184 #if defined(PLF_UNIX_TCPIPSTACK) || defined(PLF_WINNT_TCPIPSTACK)
00185 return( connect( s, Saddr, size_sockaddr) );
00186 #endif
00187
00188 #ifdef PLF_LWIP_TCPIPSTACK
00189 return( lwip_connect( s, (sockaddr *) Saddr, size_sockaddr) );
00190 #endif
00191
00192 #ifdef PLF_NICHE_TCPIPSTACK
00193 return( bsd_connect( s, (sockaddr *) Saddr, size_sockaddr) );
00194 #endif
00195
00196 }
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213 INT32 platformSocketBind( socktype s, const struct sockaddr * Saddr, size_t size_sockaddr)
00214 {
00215 #if defined(PLF_UNIX_TCPIPSTACK) || defined(PLF_WINNT_TCPIPSTACK)
00216 return( bind( s, Saddr, size_sockaddr) );
00217 #endif
00218
00219 #ifdef PLF_LWIP_TCPIPSTACK
00220 return( lwip_bind( s, (sockaddr *) Saddr, size_sockaddr) );
00221 #endif
00222
00223 #ifdef PLF_NICHE_TCPIPSTACK
00224 return( bsd_bind( s, (sockaddr *) Saddr, size_sockaddr) );
00225 #endif
00226 }
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242 INT32 platformSocketClose( socktype s )
00243 {
00244 #ifdef PLF_UNIX_TCPIPSTACK
00245
00246
00247 return( close( s ) );
00248 #endif
00249
00250 #ifdef PLF_WINNT_TCPIPSTACK
00251 const int SD_SEND_WIN = 0x01;
00252 shutdown(s, SD_SEND_WIN);
00253
00254 return( closesocket( s ) );
00255 #endif
00256
00257 #ifdef PLF_LWIP_TCPIPSTACK
00258 return( lwip_close( s ) );
00259 #endif
00260
00261 #ifdef PLF_NICHE_TCPIPSTACK
00262 return( bsd_close( s ) );
00263 #endif
00264
00265 }
00266
00267 INT32 platformSocketSelect(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)
00268 {
00269 #if defined(PLF_UNIX_TCPIPSTACK) || defined(PLF_WINNT_TCPIPSTACK)
00270 return( select( n, readfds, writefds, exceptfds, timeout) );
00271 #endif
00272
00273 #ifdef PLF_LWIP_TCPIPSTACK
00274 return( lwip_select( n, readfds, writefds, exceptfds, timeout) );
00275 #endif
00276
00277 #ifdef PLF_NICHE_TCPIPSTACK
00278 return( bsd_select( n, readfds, writefds, exceptfds, timeout) );
00279 #endif
00280
00281 }
00282
00283
00284
00285
00286
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297 INT32 platformSocketReceiveFromFunction( socktype s, UINT8 *buf, UINT32 buflen, UINT32 &ip_hostorder, UINT16 &port_hostorder)
00298 {
00299 INT32 retval;
00300
00301 struct sockaddr_in fromaddr;
00302
00303 #if defined(PLF_UNIX_TCPIPSTACK) || defined(PLF_LWIP_TCPIPSTACK)
00304 socklen_t addrlen;
00305 #endif
00306 #if defined(PLF_WINNT_TCPIPSTACK) || defined(PLF_NICHE_TCPIPSTACK)
00307 INT32 addrlen;
00308 #endif
00309
00310 addrlen = sizeof(fromaddr);
00311
00312 #if defined(PLF_UNIX_TCPIPSTACK) || defined(PLF_WINNT_TCPIPSTACK)
00313 retval = recvfrom(s, (char *) buf, (INT32) buflen, 0, (sockaddr *) &fromaddr, &addrlen );
00314 #endif
00315
00316 #ifdef PLF_LWIP_TCPIPSTACK
00317 retval = lwip_recvfrom(s, (char *) buf, (INT32) buflen, 0, (sockaddr *) &fromaddr, &addrlen );
00318 #endif
00319
00320 #ifdef PLF_NICHE_TCPIPSTACK
00321 retval = bsd_recvfrom(s, (char *) buf, (INT32) buflen, 0, (sockaddr *) &fromaddr, &addrlen );
00322 #endif
00323
00324 if (retval >= 0)
00325 {
00326 ip_hostorder = ntohl(fromaddr.sin_addr.s_addr);
00327 port_hostorder = ntohs(fromaddr.sin_port);
00328 }
00329
00330 return retval;
00331 }
00332
00333 INT32 platformSocketSendToFunction( socktype s, const UINT8 *buf, UINT32 buflen, UINT32 ip_hostorder, UINT16 port_hostorder )
00334 {
00335 struct sockaddr_in toaddr;
00336
00337 toaddr.sin_family = AF_INET;
00338 toaddr.sin_port = htons(port_hostorder);
00339 toaddr.sin_addr.s_addr = htonl(ip_hostorder);
00340
00341 #if defined(PLF_UNIX_TCPIPSTACK) || defined(PLF_WINNT_TCPIPSTACK)
00342 return( sendto(s, (const char *) buf, (INT32) buflen, 0, (const sockaddr *) &toaddr, sizeof(toaddr)) );
00343 #endif
00344
00345 #ifdef PLF_LWIP_TCPIPSTACK
00346 return( lwip_sendto(s, (void *) buf, (INT32) buflen, 0, (sockaddr *) &toaddr, sizeof(toaddr)) );
00347 #endif
00348
00349 #ifdef PLF_NICHE_TCPIPSTACK
00350 return( bsd_sendto(s, (char *) buf, (INT32) buflen, 0, (sockaddr *) &toaddr, sizeof(toaddr)) );
00351 #endif
00352 }
00353
00354 INT32 platformSocketDisconnectUDP( socktype s)
00355 {
00356 #if defined(PLF_UNIX_TCPIPSTACK) || defined(PLF_WINNT_TCPIPSTACK)
00357 struct sockaddr disconn;
00358
00359 memset(&disconn, 0, sizeof (disconn));
00360 disconn.sa_family = AF_UNSPEC;
00361 INT32 ret = connect(s, &disconn, sizeof(disconn) );
00362 if (ret == SOCKET_ERROR) return SOCKET_ERROR;
00363
00364 return 0;
00365
00366 #endif
00367
00368 #ifdef PLF_LWIP_TCPIPSTACK
00369
00370 return 0;
00371 #endif
00372
00373 #ifdef PLF_NICHE_TCPIPSTACK
00374 struct sockaddr disconn;
00375
00376 memset(&disconn, 0, sizeof (disconn));
00377 disconn.sa_family = AF_UNSPEC;
00378 INT32 ret = bsd_connect(s, &disconn, sizeof(disconn) );
00379 if (ret == SOCKET_ERROR) return SOCKET_ERROR;
00380
00381 return 0;
00382
00383 #endif
00384
00385 }
00386
00387
00388
00389
00390
00391
00392
00393
00394 INT32 platformSocketSetNonblocking ( socktype s )
00395 {
00396 #ifdef PLF_UNIX_TCPIPSTACK
00397 return fcntl( s, F_SETFL, FNONBLOCK | FASYNC );
00398 #endif
00399
00400 #ifdef PLF_WINNT_TCPIPSTACK
00401 unsigned long nonblock = 1;
00402
00403 return( ioctlsocket( s, FIONBIO, &nonblock) );
00404 #endif
00405
00406 #ifdef PLF_LWIP_TCPIPSTACK
00407 unsigned long nonblock = 1;
00408
00409 return( lwip_ioctl( s, FIONBIO, &nonblock) );
00410 #endif
00411
00412 #ifdef PLF_NICHE_TCPIPSTACK
00413 unsigned long nonblock = 1;
00414
00415 return( bsd_ioctl( s, FIONBIO, &nonblock) );
00416 #endif
00417
00418 }
00419
00420 #endif // __NEED_SOCKET_FUNCTIONS_SW__
00421
00422
00423 #ifdef PLF_USING_PTHREAD
00424
00425
00426
00427 int g_plf_send_prio;
00428 void *internalThreadProcSendStatic( LPVOID p )
00429 {
00430 CNetworkQueue *q;
00431
00432
00433
00434
00435
00436
00437
00438
00439 q = (CNetworkQueue *) p;
00440 q->SendProcessTask();
00441
00442 return NULL;
00443 }
00444
00445
00446 int g_plf_recv_prio;
00447 void *internalThreadProcReceiveStatic( LPVOID p )
00448 {
00449 CNetworkQueue *q;
00450
00451
00452
00453
00454
00455
00456
00457 q = (CNetworkQueue *) p;
00458 q->ReceiveProcessTask();
00459
00460 return NULL;
00461 }
00462
00463
00464
00465 typedef struct
00466 {
00467 pthread_t threadId1;
00468 pthread_attr_t pthread_attr;
00469 } thread_private_struct, *thread_private;
00470
00471
00472
00473 HANDLE platformCreateThread( bool sendthread, VOIDP parameter, UINT32 thread_prio_sw)
00474 {
00475 HANDLE plf_thread;
00476 thread_private hThread;
00477 int rc;
00478 int plf_prio;
00479
00480 switch( thread_prio_sw)
00481 {
00482 case SW_THREAD_PRIORITY_ABOVE_NORMAL:
00483 plf_prio = -5;
00484 break;
00485
00486 case SW_THREAD_PRIORITY_NORMAL:
00487 plf_prio = 0;
00488 break;
00489
00490 case SW_THREAD_PRIORITY_BELOW_NORMAL:
00491 plf_prio = +5;
00492 break;
00493
00494 default: return NULL;
00495 break;
00496 }
00497
00498 hThread = (thread_private) malloc(sizeof(thread_private_struct));
00499 if (hThread == NULL) return NULL;
00500
00501 if ( (rc = pthread_attr_init(&(hThread->pthread_attr))) )
00502 {
00503 _DEBUG_(printf( "pthread_attr_init ERROR.\n" ));
00504 free( hThread );
00505 return NULL;
00506 }
00507
00508
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519 if (sendthread == true)
00520 {
00521 g_plf_send_prio = plf_prio;
00522 if ( (rc = pthread_create(&(hThread->threadId1), &(hThread->pthread_attr), internalThreadProcSendStatic, parameter )) )
00523 {
00524 _DEBUG_(printf( "pthread_create ERROR.\n" ));
00525 pthread_attr_destroy(&(hThread->pthread_attr));
00526 free( hThread );
00527
00528 return NULL;
00529 }
00530 }
00531 else
00532 {
00533 g_plf_recv_prio = plf_prio;
00534 if ( (rc = pthread_create(&(hThread->threadId1), &(hThread->pthread_attr), internalThreadProcReceiveStatic, parameter )) )
00535 {
00536 _DEBUG_(printf( "pthread_create ERROR.\n" ));
00537 pthread_attr_destroy(&(hThread->pthread_attr));
00538 free( hThread );
00539
00540 return NULL;
00541 }
00542 }
00543
00544 plf_thread = hThread;
00545 return plf_thread;
00546 }
00547
00548
00549 bool platformDeleteThread( HANDLE threadhandle )
00550 {
00551 if (threadhandle == NULL) return false;
00552
00553 thread_private hThread = (thread_private) threadhandle;
00554
00555 pthread_attr_destroy(&(hThread->pthread_attr));
00556
00557 free( hThread );
00558
00559 return true;
00560 }
00561
00562
00563 typedef struct
00564 {
00565 pthread_mutex_t mutex;
00566 pthread_cond_t condition;
00567 int semCount;
00568 int semMaxCount;
00569 }sem_private_struct, *sem_private;
00570
00571
00572 HANDLE platformCreateSemaphore( UINT16 maximum_count )
00573 {
00574 HANDLE sem;
00575 int rc;
00576
00577 sem_private token;
00578
00579 token = (sem_private) malloc(sizeof(sem_private_struct));
00580
00581 if ((rc = pthread_mutex_init(&(token->mutex), NULL)))
00582 {
00583 free(token);
00584
00585 return NULL;
00586 }
00587
00588 if ((rc = pthread_cond_init(&(token->condition), NULL)))
00589 {
00590 pthread_mutex_destroy( &(token->mutex) );
00591 free(token);
00592
00593 return NULL;
00594 }
00595
00596 token->semCount = 0;
00597 token->semMaxCount = maximum_count;
00598
00599 sem = token;
00600
00601 return sem;
00602 }
00603
00604
00605 bool platformDeleteSemaphore( HANDLE semaph )
00606 {
00607 sem_private token = (sem_private) semaph;
00608
00609 if (token == NULL) return false;
00610
00611 pthread_mutex_destroy(&(token->mutex));
00612
00613 pthread_cond_destroy(&(token->condition));
00614
00615 free (token);
00616
00617 return true;
00618 }
00619
00620
00621 bool platformWaitForSemaphore( HANDLE semaph, UINT32 timeout_msec )
00622 {
00623 int rc;
00624 struct timespec tm;
00625 struct timeb tp;
00626 long sec, millisec;
00627
00628 sem_private token = (sem_private) semaph;
00629
00630 if ((rc = pthread_mutex_lock(&(token->mutex)))) return false;
00631
00632 if (timeout_msec > 0)
00633 {
00634 sec = timeout_msec / 1000;
00635 millisec = timeout_msec % 1000;
00636 ftime( &tp );
00637 tp.time += sec;
00638 tp.millitm += millisec;
00639
00640 if( tp.millitm > 999 )
00641 {
00642 tp.millitm -= 1000;
00643 tp.time++;
00644 }
00645
00646 tm.tv_sec = tp.time;
00647 tm.tv_nsec = tp.millitm * 1000000 ;
00648 }
00649
00650 while (token->semCount <= 0)
00651 {
00652 if (timeout_msec == 0)
00653 {
00654 rc = pthread_cond_wait(&(token->condition), &(token->mutex));
00655 }
00656 else
00657 {
00658 rc = pthread_cond_timedwait(&(token->condition), &(token->mutex), &tm);
00659 }
00660 if (rc && (errno != EINTR) )
00661 break;
00662 }
00663
00664 if (rc)
00665 {
00666 if ( pthread_mutex_unlock(&(token->mutex)) ) return false;
00667
00668 if ( rc == ETIMEDOUT )
00669 {
00670
00671 return false;
00672 }
00673
00674 return false;
00675 }
00676
00677 token->semCount--;
00678
00679 if ((rc = pthread_mutex_unlock(&(token->mutex)))) return false;
00680
00681 return true;
00682 }
00683
00684
00685 bool platformSignalSemaphore( HANDLE semaphore )
00686 {
00687 bool retval = true;
00688 int rc;
00689
00690 sem_private token = (sem_private) semaphore;
00691
00692 if (token == NULL) return false;
00693
00694 if ((rc = pthread_mutex_lock(&(token->mutex)))) return false;
00695
00696 if (token->semCount < token->semMaxCount)
00697 {
00698 token->semCount ++;
00699 }
00700 else retval = false;
00701
00702 if ((rc = pthread_mutex_unlock(&(token->mutex)))) return false;
00703
00704 if (retval == true) if ((rc = pthread_cond_signal(&(token->condition)))) return false;
00705
00706 return retval;
00707 }
00708
00709
00710 bool platformIsSemaphoreSignalled( HANDLE semaph )
00711 {
00712 int rc;
00713 bool retval = true;
00714
00715 assert( semaph != NULL );
00716
00717 sem_private token = (sem_private) semaph;
00718
00719 if ((rc = pthread_mutex_lock(&(token->mutex)))) return false;
00720
00721
00722
00723 if (token->semCount <= 0) retval = false;
00724 if (retval == true) token->semCount--;
00725
00726 if ((rc = pthread_mutex_unlock(&(token->mutex)))) return false;
00727
00728 return retval;
00729 }
00730
00731
00732 typedef struct
00733 {
00734 pthread_mutex_t mutex;
00735 pthread_cond_t condition;
00736 bool mutex_set;
00737 }mtx_private_struct, *mutex_private;
00738
00739
00740 HANDLE platformCreateMutex()
00741 {
00742 mutex_private mutexstruct;
00743 int rc=0;
00744 HANDLE mutex_ret;
00745
00746 mutexstruct = (mutex_private) malloc(sizeof(mtx_private_struct));
00747 if (mutexstruct == NULL) return NULL;
00748
00749
00750 if ( (rc = pthread_mutex_init( &(mutexstruct->mutex), NULL) ))
00751 {
00752 free( mutexstruct );
00753 return NULL;
00754 }
00755
00756 if( (rc = pthread_cond_init(&(mutexstruct->condition), NULL)) )
00757 {
00758 pthread_mutex_destroy( &(mutexstruct->mutex) );
00759 free(mutexstruct);
00760
00761 return NULL;
00762 }
00763
00764 mutexstruct->mutex_set = false;
00765
00766 mutex_ret = mutexstruct;
00767
00768 return mutex_ret;
00769 }
00770
00771
00772 bool platformDeleteMutex( HANDLE mutex )
00773 {
00774 if (mutex == NULL) return false;
00775 int rc;
00776 mutex_private mutexstruct = (mutex_private) mutex;
00777
00778 if ( (rc = pthread_cond_destroy(&(mutexstruct->condition))) ) return false;
00779 if ( (rc = pthread_mutex_destroy(&(mutexstruct->mutex))) ) return false;
00780
00781 free(mutexstruct);
00782
00783 return true;
00784 }
00785
00786
00787 bool platformWaitForMutex( HANDLE mutex, UINT32 timeout_msec )
00788 {
00789 if (mutex == NULL) return false;
00790
00791 mutex_private mutexstruct = (mutex_private) mutex;
00792 int rc=0;
00793 struct timespec tm;
00794 struct timeb tp;
00795 long sec, millisec;
00796
00797
00798 if ((rc = pthread_mutex_lock(&(mutexstruct->mutex)))) return false;
00799
00800 if (mutexstruct->mutex_set == false)
00801 {
00802 return true;
00803 }
00804
00805 if (timeout_msec > 0)
00806 {
00807 sec = timeout_msec / 1000;
00808 millisec = timeout_msec % 1000;
00809 ftime( &tp );
00810 tp.time += sec;
00811 tp.millitm += millisec;
00812
00813 if( tp.millitm > 999 )
00814 {
00815 tp.millitm -= 1000;
00816 tp.time++;
00817 }
00818
00819 tm.tv_sec = tp.time;
00820 tm.tv_nsec = tp.millitm * 1000000 ;
00821 }
00822
00823 do
00824 {
00825 if (timeout_msec == 0)
00826 {
00827 rc = pthread_cond_wait(&(mutexstruct->condition), &(mutexstruct->mutex));
00828 }
00829 else
00830 {
00831 rc = pthread_cond_timedwait(&(mutexstruct->condition), &(mutexstruct->mutex), &tm);
00832 }
00833 if (rc && (errno != EINTR) ) break;
00834 }
00835 while (mutexstruct->mutex_set == true);
00836
00837
00838 if (rc)
00839 {
00840 if ( pthread_mutex_unlock(&(mutexstruct->mutex)) ) return false;
00841
00842 if ( rc == ETIMEDOUT ) return false;
00843
00844 return false;
00845 }
00846
00847 if ((rc = pthread_mutex_lock(&(mutexstruct->mutex)))) return false;
00848 mutexstruct->mutex_set = true;
00849
00850
00851 return true;
00852 }
00853
00854
00855 bool platformSignalMutex( HANDLE mutex )
00856 {
00857
00858
00859 if (mutex == NULL) return false;
00860 mutex_private mutexstruct = (mutex_private) mutex;
00861 int rc=0;
00862
00863 if ((rc = pthread_mutex_unlock(&(mutexstruct->mutex))) ) return false;
00864 mutexstruct->mutex_set = false;
00865 pthread_cond_signal(&(mutexstruct->condition));
00866
00867 return true;
00868 }
00869
00870 #endif // PLF_USING_PTHREAD only
00871
00872 #if defined(PLF_SYSTEM_SOLARIS) || defined(PLF_SYSTEM_LINUX) || defined(PLF_SYSTEM_NIOS2)
00873
00874
00875 UINT32 platformGetLastError()
00876 {
00877 return( errno );
00878 }
00879
00880
00881 INT32 platformSocketGetLastError()
00882 {
00883 return( errno );
00884 }
00885
00886
00887 ONECHAR *platformGetOSErrorString( UINT32 intOSLastError, ONECHAR *lasterrorstr, UINT32 maxlength_lasterrorstr)
00888 {
00889 char *lbuf = strerror( intOSLastError );
00890 unsigned int len = strlen(lbuf);
00891
00892 if (len >= maxlength_lasterrorstr) len = maxlength_lasterrorstr - 1;
00893 memcpy(lasterrorstr, lbuf, len);
00894 lasterrorstr[len] = 0;
00895
00896 return lasterrorstr;
00897 }
00898
00899
00900 #endif // unix, solaris, nios2 only
00901
00902
00903
00904 #ifdef PLF_SYSTEM_WINNT
00905
00906
00907 UINT32 platformGetLastError()
00908 {
00909 return( GetLastError() );
00910 }
00911
00912
00913 INT32 platformSocketGetLastError()
00914 {
00915 INT32 lasterr = WSAGetLastError();
00916 INT32 retcode;
00917
00918 switch( lasterr )
00919 {
00920 case WSAEADDRNOTAVAIL: retcode = EADDRNOTAVAIL;
00921 break;
00922
00923 case WSAEAFNOSUPPORT: retcode = EAFNOSUPPORT;
00924 break;
00925
00926 case WSAEALREADY: retcode = EALREADY;
00927 break;
00928
00929 case WSAEBADF: retcode = EBADF;
00930 break;
00931
00932 case WSAECONNREFUSED: retcode = ECONNREFUSED;
00933 break;
00934
00935 case WSAEINPROGRESS: retcode = EINPROGRESS;
00936 break;
00937
00938 case WSAEINTR: retcode = EINTR;
00939 break;
00940
00941 case WSAEISCONN: retcode = EISCONN;
00942 break;
00943
00944 case WSAENETUNREACH: retcode = ENETUNREACH;
00945 break;
00946
00947 case WSAENOTSOCK: retcode = ENOTSOCK;
00948 break;
00949
00950 case WSAEPROTOTYPE: retcode = EPROTOTYPE;
00951 break;
00952
00953 case WSAETIMEDOUT: retcode = ETIMEDOUT;
00954 break;
00955
00956 case WSAEADDRINUSE: retcode = EADDRINUSE;
00957 break;
00958
00959 case WSAECONNRESET: retcode = ECONNRESET;
00960 break;
00961
00962 case WSAEHOSTUNREACH: retcode = EHOSTUNREACH;
00963 break;
00964
00965 case WSAEINVAL: retcode = EINVAL;
00966 break;
00967
00968 case WSAEHOSTDOWN: retcode = EHOSTDOWN;
00969 break;
00970
00971 case WSAENAMETOOLONG: retcode = ENAMETOOLONG;
00972 break;
00973
00974 case WSAENETDOWN: retcode = ENETDOWN;
00975 break;
00976
00977 case WSAEWOULDBLOCK: retcode = EAGAIN;
00978 break;
00979
00980 default: retcode = EUNKNOWN;
00981 break;
00982
00983 }
00984
00985 return retcode;
00986 }
00987
00988
00989
00990
00991
00992
00993
00994
00995
00996
00997
00998
00999
01000
01001
01002
01003
01004
01005
01006
01007
01008
01009 ONECHAR *platformGetOSErrorString( UINT32 intOSLastError, ONECHAR *lasterrorstr, UINT32 maxlength_lasterrorstr)
01010 {
01011 assert( lasterrorstr != NULL );
01012
01013 LPSTR MessageBuffer;
01014 DWORD dwBufferLength;
01015
01016 DWORD dwFormatFlags = FORMAT_MESSAGE_ALLOCATE_BUFFER |
01017 FORMAT_MESSAGE_IGNORE_INSERTS |
01018 FORMAT_MESSAGE_FROM_SYSTEM ;
01019
01020
01021
01022
01023
01024
01025
01026 strcpy((char *) lasterrorstr, "Unknown error.");
01027
01028 dwBufferLength = FormatMessageA(dwFormatFlags,
01029 NULL,
01030 intOSLastError,
01031 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
01032 (LPSTR) &MessageBuffer,
01033 0,
01034 NULL);
01035 if (dwBufferLength > 0)
01036 {
01037
01038 if (MessageBuffer[strlen(MessageBuffer)-1] == 10) MessageBuffer[strlen(MessageBuffer)-1] = 0;
01039 if (MessageBuffer[strlen(MessageBuffer)-1] == 13) MessageBuffer[strlen(MessageBuffer)-1] = 0;
01040
01041
01042 unsigned int len = strlen(MessageBuffer);
01043
01044 if (len >= maxlength_lasterrorstr) len = maxlength_lasterrorstr - 1;
01045 memcpy(lasterrorstr, MessageBuffer, len);
01046 lasterrorstr[len] = 0;
01047
01048 LocalFree(MessageBuffer);
01049 }
01050
01051 return lasterrorstr;
01052 }
01053
01054
01055
01056
01057
01058
01059
01060
01061
01062
01063
01064
01065
01066
01067
01068
01069
01070
01071
01072
01073
01074 int g_plf_send_prio;
01075 HANDLE g_plf_send_thread;
01076
01077 DWORD WINAPI internalThreadProcSendStatic( LPVOID p )
01078 {
01079 CNetworkQueue *q;
01080
01081 BOOL ret = SetThreadPriority( g_plf_send_thread, g_plf_send_prio);
01082 assert( ret == TRUE );
01083
01084 q = (CNetworkQueue *) p;
01085 q->SendProcessTask();
01086
01087 return 0;
01088 }
01089
01090
01091
01092
01093
01094
01095
01096
01097
01098
01099
01100
01101
01102
01103 int g_plf_recv_prio;
01104 HANDLE g_plf_recv_thread;
01105
01106 DWORD WINAPI internalThreadProcReceiveStatic( LPVOID p )
01107 {
01108 CNetworkQueue *q;
01109
01110 BOOL ret = SetThreadPriority( g_plf_recv_thread, g_plf_recv_prio);
01111 assert( ret == TRUE );
01112
01113 q = (CNetworkQueue *) p;
01114 q->ReceiveProcessTask();
01115
01116 return 0;
01117 }
01118
01119
01120
01121
01122
01123
01124
01125
01126
01127
01128
01129
01130
01131
01132
01133
01134
01135
01136
01137
01138 HANDLE platformCreateThread( bool sendthread, VOIDP parameter, UINT32 thread_prio_sw)
01139 {
01140 HANDLE plf_thread;
01141 int plf_prio;
01142
01143 switch( thread_prio_sw)
01144 {
01145
01146 case SW_THREAD_PRIORITY_ABOVE_NORMAL:
01147 plf_prio = THREAD_PRIORITY_ABOVE_NORMAL;
01148 break;
01149
01150 case SW_THREAD_PRIORITY_NORMAL:
01151 plf_prio = THREAD_PRIORITY_NORMAL;
01152 break;
01153
01154 case SW_THREAD_PRIORITY_BELOW_NORMAL:
01155 plf_prio = THREAD_PRIORITY_BELOW_NORMAL;
01156 break;
01157
01158 default: return NULL;
01159 break;
01160
01161 }
01162
01163 if (sendthread == true)
01164 {
01165 DWORD dummy_thread_id_send;
01166 plf_thread = CreateThread(NULL, 0, internalThreadProcSendStatic, parameter, CREATE_SUSPENDED, &dummy_thread_id_send );
01167 if (plf_thread != NULL)
01168 {
01169 g_plf_send_prio = plf_prio;
01170 g_plf_send_thread = plf_thread;
01171 ResumeThread(g_plf_send_thread);
01172 }
01173 }
01174 else
01175 {
01176 DWORD dummy_thread_id_recv;
01177 plf_thread = CreateThread(NULL, 0, internalThreadProcReceiveStatic, parameter, CREATE_SUSPENDED, &dummy_thread_id_recv );
01178 if (plf_thread != NULL)
01179 {
01180 g_plf_recv_prio = plf_prio;
01181 g_plf_recv_thread = plf_thread;
01182 ResumeThread(g_plf_recv_thread);
01183 }
01184 }
01185
01186 if (plf_thread == NULL) return NULL;
01187
01188 return plf_thread;
01189 }
01190
01191
01192
01193
01194
01195
01196
01197
01198
01199
01200
01201 bool platformDeleteThread( HANDLE threadhandle )
01202 {
01203 if (threadhandle == NULL) return false;
01204
01205 if (CloseHandle( threadhandle ) == TRUE) return true;
01206
01207 return false;
01208 }
01209
01210
01211
01212
01213
01214
01215
01216
01217
01218
01219
01220
01221
01222
01223
01224
01225
01226
01227
01228 HANDLE platformCreateSemaphore( UINT16 maximum_count )
01229 {
01230 HANDLE sem;
01231
01232 sem = CreateSemaphore(NULL, 0, maximum_count, NULL);
01233 if (sem == NULL) return( NULL );
01234
01235 return sem;
01236 }
01237
01238
01239
01240
01241
01242
01243
01244
01245
01246
01247 bool platformDeleteSemaphore( HANDLE semaph )
01248 {
01249 if (semaph == NULL) return false;
01250
01251 if (CloseHandle( semaph ) == TRUE) return true;
01252
01253 return false;
01254 }
01255
01256
01257
01258
01259
01260
01261
01262
01263
01264
01265
01266
01267
01268
01269
01270
01271 bool platformWaitForSemaphore( HANDLE semaph, UINT32 timeout_msec )
01272 {
01273 assert( semaph != NULL);
01274
01275 if (timeout_msec == 0) timeout_msec = INFINITE;
01276
01277 DWORD ret = WaitForSingleObject(semaph, timeout_msec);
01278 if (ret == WAIT_OBJECT_0) return true;
01279
01280 return false;
01281 }
01282
01283
01284
01285
01286
01287
01288
01289
01290
01291
01292
01293
01294
01295
01296
01297
01298
01299
01300 bool platformIsSemaphoreSignalled( HANDLE semaph )
01301 {
01302 assert( semaph != NULL);
01303
01304 DWORD ret = WaitForSingleObject(semaph, 0);
01305 if (ret == WAIT_OBJECT_0) return true;
01306
01307 return false;
01308 }
01309
01310
01311
01312
01313
01314
01315
01316
01317
01318
01319
01320
01321
01322
01323
01324
01325 bool platformSignalSemaphore( HANDLE semaphore )
01326 {
01327 assert( semaphore != NULL );
01328
01329 BOOL ret = ReleaseSemaphore( semaphore, 1, NULL);
01330
01331 if (ret == TRUE) return true;
01332
01333 return false;
01334 }
01335
01336
01337
01338
01339
01340
01341
01342
01343
01344
01345
01346
01347
01348
01349
01350
01351
01352
01353 HANDLE platformCreateMutex()
01354 {
01355 HANDLE sem;
01356
01357 sem = CreateSemaphore(NULL, 1, 1, NULL);
01358 if (sem == NULL) return( NULL );
01359
01360 return sem;
01361 }
01362
01363
01364
01365
01366
01367
01368
01369
01370
01371
01372 bool platformDeleteMutex( HANDLE binsem )
01373 {
01374 if (binsem == NULL) return false;
01375
01376 if (CloseHandle( binsem ) == TRUE) return true;
01377
01378 return false;
01379 }
01380
01381
01382
01383
01384
01385
01386
01387
01388
01389
01390
01391
01392
01393
01394
01395
01396
01397 bool platformWaitForMutex( HANDLE binsem, UINT32 timeout_msec )
01398 {
01399 UINT32 iter=0;
01400 bool retval = false;
01401
01402 assert( binsem != NULL );
01403
01404 if (timeout_msec == 0) timeout_msec = INFINITE;
01405
01406
01407 while( 1==1 )
01408 {
01409 iter++;
01410 DWORD ret = WaitForSingleObject(binsem, timeout_msec);
01411 if (ret == WAIT_OBJECT_0)
01412 {
01413 retval = true;
01414 break;
01415 }
01416
01417 _DEBUG_(if (ret == WAIT_FAILED) printf("plfWaitForMutex(win): WAIT_FAILED glerror=%d\n", GetLastError() ));
01418 _DEBUG_(if (ret == WAIT_ABANDONED) printf("plfWaitForMutex(win): WAIT_ABANDONED glerror=%d\n", GetLastError() ));
01419
01420 if ((ret == WAIT_FAILED) || (ret == WAIT_ABANDONED)) break;
01421 }
01422
01423 _DEBUG_(if (iter > 1) printf("plfWaitForMutex(win): required %u iterations of %u msec before mutex was signalled.\n", iter, timeout_msec));
01424
01425 return retval;
01426 }
01427
01428
01429
01430
01431
01432
01433
01434
01435
01436
01437
01438
01439
01440
01441
01442
01443
01444 bool platformSignalMutex( HANDLE binsem )
01445 {
01446 assert( binsem != NULL );
01447
01448 if (ReleaseSemaphore(binsem,1, NULL) == TRUE) return true;
01449
01450 return false;
01451 }
01452
01453 #endif // PLF_SYSTEM_WINNT
01454
01455 #ifdef SYSTEM_NIOS2_NICHE
01456
01457 void internalThreadProcSendStatic( LPVOID p )
01458 {
01459 CNetworkQueue *q;
01460
01461 q = (CNetworkQueue *) p;
01462 q->SendProcessTask();
01463 OSTaskDel(OS_PRIO_SELF);
01464 }
01465
01466
01467 void internalThreadProcReceiveStatic( LPVOID p )
01468 {
01469 CNetworkQueue *q;
01470
01471 q = (CNetworkQueue *) p;
01472 q->ReceiveProcessTask();
01473 OSTaskDel(OS_PRIO_SELF);
01474 }
01475
01476
01477
01478
01479
01480
01481
01482 TK_OBJECT(to_internalThreadProcReceiveStatic);
01483 TK_ENTRY(internalThreadProcReceiveStatic);
01484
01485 TK_OBJECT(to_internalThreadProcSendStatic);
01486 TK_ENTRY(internalThreadProcSendStatic);
01487
01488
01489
01490 struct inet_taskinfo SendStatic = {
01491 &to_internalThreadProcSendStatic,
01492 "send task (network queue)",
01493 internalThreadProcSendStatic,
01494 SENDTASK_PRIO_SW,
01495 TASK_STACK_SIZE_SW,
01496 };
01497
01498
01499
01500 struct inet_taskinfo ReceiveStatic = {
01501 &to_internalThreadProcReceiveStatic,
01502 "recv task (network queue)",
01503 internalThreadProcReceiveStatic,
01504 RECVTASK_PRIO_SW,
01505 TASK_STACK_SIZE_SW,
01506
01507 };
01508
01509 HANDLE platformCreateThread( bool sendthread, VOIDP parameter, UINT32 prio_not_used)
01510 {
01511 int err;
01512 INT32U prio;
01513
01514 if (sendthread == true)
01515 {
01516 SendStatic.task_parameter = parameter;
01517 err = TK_NEWTASK(&SendStatic);
01518 prio = SendStatic.priority;
01519 }
01520 else
01521 {
01522 ReceiveStatic.task_parameter = parameter;
01523 err = TK_NEWTASK(&ReceiveStatic);
01524 prio = ReceiveStatic.priority;
01525 }
01526
01527 if (err == 0)
01528 {
01529 return (OS_EVENT *) prio;
01530 }
01531
01532 return NULL;
01533 }
01534
01535 bool platformDeleteThread( HANDLE threadhandle )
01536 {
01537 INT32U tmp = (INT32U) threadhandle;
01538 INT8U prio = (INT8U) tmp;
01539
01540 if (threadhandle == NULL) return false;
01541 INT8U err = OSTaskDel(prio);
01542 if (err == OS_NO_ERR) return true;
01543
01544 return false;
01545 }
01546 #endif
01547
01548 #ifdef SYSTEM_NIOS2_LWIP
01549
01550
01551
01552
01553
01554
01555
01556 UINT32 internalThreadProcSendStatic( LPVOID p )
01557 {
01558 CNetworkQueue *q;
01559
01560 q = (CNetworkQueue *) p;
01561 q->SendProcessTask();
01562 OSTaskDel(OS_PRIO_SELF);
01563
01564 return 0;
01565 }
01566
01567
01568 UINT32 internalThreadProcReceiveStatic( LPVOID p )
01569 {
01570 CNetworkQueue *q;
01571
01572 q = (CNetworkQueue *) p;
01573 q->ReceiveProcessTask();
01574 OSTaskDel(OS_PRIO_SELF);
01575
01576 return 0;
01577 }
01578
01579
01580
01581 static OS_STK SendTaskStack[TASK_STACK_SIZE_SW/sizeof(OS_STK)];
01582
01583
01584 static OS_STK ReceiveTaskStack[TASK_STACK_SIZE_SW/sizeof(OS_STK)];
01585
01586
01587
01588 HANDLE platformCreateThread( bool sendthread, VOIDP parameter, UINT32 prio_not_used)
01589 {
01590 INT8U err;
01591 INT32U prio;
01592
01593 if (sendthread == true)
01594 {
01595
01596 #if OS_STK_GROWTH == 0
01597 err = OSTaskCreateExt((void(*)(void*))internalThreadProcSendStatic, parameter,
01598 &SendTaskStack[0], SENDTASK_PRIO_SW, SENDTASK_PRIO_SW,
01599 &SendTaskStack[(TASK_STACK_SIZE_SW/sizeof(OS_STK))-1], (TASK_STACK_SIZE_SW/sizeof(OS_STK)),
01600 NULL, TASK_STACK_CHECKING_SW);
01601 #else
01602 err = OSTaskCreateExt((void(*)(void*))internalThreadProcSendStatic, parameter,
01603 &SendTaskStack[(TASK_STACK_SIZE_SW/sizeof(OS_STK))-1], SENDTASK_PRIO_SW,
01604 SENDTASK_PRIO_SW, &SendTaskStack[0], (TASK_STACK_SIZE_SW/sizeof(OS_STK)),
01605 NULL, TASK_STACK_CHECKING_SW);
01606 #endif
01607 prio = SENDTASK_PRIO_SW;
01608 }
01609 else
01610 {
01611 #if OS_STK_GROWTH == 0
01612 err = OSTaskCreateExt((void(*)(void*))internalThreadProcReceiveStatic, parameter,
01613 &ReceiveTaskStack[0], RECVTASK_PRIO_SW, RECVTASK_PRIO_SW,
01614 &ReceiveTaskStack[(TASK_STACK_SIZE_SW/sizeof(OS_STK))-1], (TASK_STACK_SIZE_SW/sizeof(OS_STK)),
01615 NULL, TASK_STACK_CHECKING_SW);
01616 #else
01617 err = OSTaskCreateExt((void(*)(void*))internalThreadProcReceiveStatic, parameter,
01618 &ReceiveTaskStack[(TASK_STACK_SIZE_SW/sizeof(OS_STK))-1], RECVTASK_PRIO_SW,
01619 RECVTASK_PRIO_SW, &ReceiveTaskStack[0], (TASK_STACK_SIZE_SW/sizeof(OS_STK)),
01620 NULL, TASK_STACK_CHECKING_SW);
01621 #endif
01622 prio = RECVTASK_PRIO_SW;
01623 }
01624
01625 if (err == OS_NO_ERR)
01626 {
01627 return (OS_EVENT *) prio;
01628 }
01629
01630 return NULL;
01631 }
01632
01633
01634 bool platformDeleteThread( HANDLE threadhandle )
01635 {
01636 INT32U tmp = (INT32U) threadhandle;
01637 INT8U prio = (INT8U) tmp;
01638
01639 if (threadhandle == NULL) return false;
01640 INT8U err = OSTaskDel(prio);
01641 if (err == OS_NO_ERR) return true;
01642
01643 return false;
01644 }
01645 #endif
01646
01647 #ifdef PLF_SYSTEM_NIOS2
01648
01649
01650
01651
01652
01653
01654
01655
01656
01657
01658
01659 typedef struct
01660 {
01661 OS_EVENT *binlock;
01662 OS_EVENT *ucosSemaphore;
01663 UINT16 semMaxCount;
01664 }sem_private_struct, *sem_private;
01665
01666
01667 HANDLE platformCreateSemaphore( UINT16 maximum_count )
01668 {
01669 sem_private token;
01670 INT8U err;
01671
01672 if (maximum_count < 1) return NULL;
01673
01674 token = (sem_private) malloc(sizeof(sem_private_struct));
01675 if (token == NULL) return NULL;
01676
01677 token->semMaxCount = maximum_count;
01678 token->ucosSemaphore = OSSemCreate(0);
01679 if (token->ucosSemaphore == NULL )
01680 {
01681 free( token );
01682 return NULL;
01683 }
01684
01685 token->binlock = OSSemCreate(1);
01686 if (token->binlock == NULL )
01687 {
01688 OSSemDel( token->ucosSemaphore, OS_DEL_ALWAYS, &err);
01689 free( token );
01690 return NULL;
01691 }
01692
01693 return (HANDLE) token;
01694 }
01695
01696
01697
01698
01699
01700
01701
01702
01703
01704
01705
01706 bool platformDeleteSemaphore( HANDLE semaph )
01707 {
01708 INT8U err;
01709
01710 sem_private token = (sem_private) semaph;
01711 if (token == NULL) return false;
01712
01713 double bintimeouttmp = (BINLOCK_SEM_TIMEOUT / 1000.0)*(OS_TICKS_PER_SEC*1.0);
01714 INT16U bintimeout_ticks = (INT16U) bintimeouttmp;
01715
01716 OSSemPend(token->binlock, bintimeout_ticks, &err);
01717 if (err != OS_NO_ERR) return false;
01718
01719 OSSemDel( token->ucosSemaphore, OS_DEL_NO_PEND, &err);
01720 if (err != OS_NO_ERR)
01721 {
01722 OSSemPost(token->binlock);
01723 return false;
01724 }
01725
01726 OSSemDel( token->binlock, OS_DEL_ALWAYS, &err);
01727 if (err != OS_NO_ERR) return false;
01728
01729 free( token );
01730
01731 return true;
01732 }
01733
01734
01735 bool platformWaitForSemaphore( HANDLE semaph, UINT32 timeout_msec )
01736 {
01737 INT8U err;
01738 bool retval=true;
01739
01740 sem_private token = (sem_private) semaph;
01741 if (token == NULL) return false;
01742
01743 INT16U timeout_ticks = (INT16U) ((timeout_msec*OS_TICKS_PER_SEC)/1000);
01744
01745 OSSemPend(token->ucosSemaphore, timeout_ticks, &err);
01746 if (err != OS_NO_ERR) retval = false;
01747
01748
01749 return retval;
01750 }
01751
01752
01753 bool platformSignalSemaphore( HANDLE semaphore )
01754 {
01755 static INT16U bintimeout_ticks=0;
01756 OS_SEM_DATA sembuf;
01757 INT8U err;
01758 bool retval = true;
01759
01760 sem_private token = (sem_private) semaphore;
01761 if (token == NULL) return false;
01762
01763 if (bintimeout_ticks == 0)
01764 {
01765 double bintimeouttmp = (BINLOCK_SEM_TIMEOUT / 1000.0)*(OS_TICKS_PER_SEC*1.0);
01766 bintimeout_ticks = (INT16U) bintimeouttmp;
01767 }
01768
01769 OSSemPend(token->binlock, bintimeout_ticks, &err);
01770 if (err != OS_NO_ERR) return false;
01771
01772 OSSemQuery(token->ucosSemaphore, &sembuf);
01773
01774 if (sembuf.OSCnt < token->semMaxCount)
01775 {
01776 err = OSSemPost(token->ucosSemaphore);
01777 if (err != OS_NO_ERR) retval = false;
01778 }
01779
01780 err = OSSemPost(token->binlock);
01781 if (err != OS_NO_ERR) retval = false;
01782
01783 return retval;
01784 }
01785
01786
01787 bool platformIsSemaphoreSignalled( HANDLE semaph )
01788 {
01789 INT16U retval;
01790
01791 assert( semaph != NULL);
01792
01793 sem_private token = (sem_private) semaph;
01794
01795 retval = OSSemAccept(token->ucosSemaphore);
01796 if (retval == 0) return( false );
01797
01798 return true;
01799 }
01800
01801
01802
01803
01804
01805
01806
01807
01808
01809 HANDLE platformCreateMutex()
01810 {
01811 return OSSemCreate(1);
01812 }
01813
01814
01815 bool platformDeleteMutex( HANDLE mutex )
01816 {
01817 INT8U err;
01818
01819 if (mutex == NULL) return false;
01820 OSSemDel( mutex, OS_DEL_NO_PEND, &err);
01821 if (err == OS_NO_ERR) return true;
01822
01823 return false;
01824 }
01825
01826
01827 bool platformWaitForMutex( HANDLE mutex, UINT32 timeout_msec )
01828 {
01829 INT8U err;
01830
01831 if (mutex == NULL) return false;
01832
01833 double timeouttmp = (timeout_msec / 1000)*(OS_TICKS_PER_SEC*1.0);
01834 INT16U timeout_ticks = (INT16U) timeouttmp;
01835
01836 OSSemPend(mutex, timeout_ticks, &err);
01837 if (err == OS_NO_ERR) return true;
01838
01839 return false;
01840 }
01841
01842
01843 bool platformSignalMutex( HANDLE mutex )
01844 {
01845 if (mutex == NULL) return false;
01846
01847 INT8U err = OSSemPost(mutex);
01848
01849 if (err == OS_NO_ERR) return true;
01850
01851 return false;
01852 }
01853
01854 #endif // PLF_SYSTEM_NIOS2
01855
01856
01857
01858 #ifndef PLF_SYSTEM_WINNT
01859
01860 #define MAXLEN 1024
01861
01863
01865
01866 void stoupper(char *s)
01867 {
01868 char *p = (char *) s;
01869
01870 if (p == NULL) return;
01871
01872 while (*p != 0)
01873 {
01874 if( islower(*p) ) *p = _toupper(*p);
01875 ++p;
01876 }
01877 }
01878
01879 static char strtmp1[MAXLEN];
01880 static char strtmp2[MAXLEN];
01881
01883
01885 int _strnicmp( const char *string1, const char *string2, size_t count)
01886 {
01887 if (count > (MAXLEN-1)) return -1;
01888
01889 strncpy(strtmp1, string1, count);
01890 strtmp1[count] = 0;
01891
01892 strncpy(strtmp2, string2, count);
01893 strtmp2[count] = 0;
01894
01895 stoupper(strtmp1);
01896 stoupper(strtmp2);
01897
01898 return strncmp( strtmp1, strtmp2, count );
01899 }
01900
01901 #endif // NO PLF_SYSTEM_WINNT
01902
01903
01904
01905
01906
01907
01908
01909
01910
01911 VOID platformSleepMilliseconds( UINT32 msec )
01912 {
01913 #if defined(PLF_SYSTEM_SOLARIS) || defined(PLF_SYSTEM_LINUX)
01914
01915 struct timespec req={0};
01916
01917 req.tv_sec=(int)(msec/1000);
01918 req.tv_nsec=(msec%1000)*1000000L;
01919
01920 while(nanosleep(&req,&req)==-1)
01921 {
01922 }
01923
01924 #endif
01925
01926 #ifdef PLF_SYSTEM_WINNT
01927 Sleep( msec );
01928 #endif
01929
01930 #ifdef PLF_SYSTEM_NIOS2
01931 INT8U lsec = (INT8U) (msec / 1000) % 60;
01932 INT16U lmsec = (INT16U) (msec % 1000);
01933 INT8U lmin = (INT8U) (((msec / 1000) / 60) % 60);
01934 INT8U lhour = (INT8U) (((msec / 1000) / 60) / 60);
01935
01936 OSTimeDlyHMSM(lhour,lmin,lsec,lmsec);
01937 #endif
01938 }
01939
01940
01941
01942
01943
01944
01945
01946
01947
01948
01949 UINT32 platformGetTickCount()
01950 {
01951 #ifdef PLF_SYSTEM_SOLARIS
01952 struct timeb current_timeval;
01953
01954 static bool first_time_set=false;
01955 static timeb first_timeval;
01956
01957 int ret = ftime(¤t_timeval);
01958 assert(ret == 0);
01959 ret=ret;
01960
01961 if (first_time_set == false)
01962 {
01963 first_timeval = current_timeval;
01964 first_time_set = true;
01965 return 0;
01966 }
01967 else
01968 {
01969 double passedmilliseconds = difftime(current_timeval.time, first_timeval.time) * 1000.0;
01970
01971 passedmilliseconds -= ((double)first_timeval.millitm);
01972 passedmilliseconds += ((double)current_timeval.millitm);
01973
01974 return( (UINT32) passedmilliseconds );
01975 }
01976
01977 #endif
01978
01979 #ifdef PLF_SYSTEM_LINUX
01980 static long tickssincestart = -1;
01981
01982 if (tickssincestart == -1) tickssincestart = sysconf(_SC_CLK_TCK);
01983
01984 struct tms tm;
01985 return (UINT32)((times(&tm)*1000.0)/tickssincestart);
01986 #endif
01987
01988 #ifdef PLF_SYSTEM_WINNT
01989 return (UINT32) ::GetTickCount();
01990 #endif
01991
01992 #ifdef PLF_SYSTEM_NIOS2
01993 INT32U tickssincestart;
01994 UINT32 msecsincestart;
01995
01996 tickssincestart = OSTimeGet();
01997
01998 msecsincestart = (UINT32) ((tickssincestart*1.0) / (1000.0/(OS_TICKS_PER_SEC*1.0)));
01999
02000 return msecsincestart;
02001 #endif
02002
02003 }
02004
02005 #if defined(PLF_SYSTEM_SOLARIS) || defined(PLF_SYSTEM_LINUX)
02006 static struct termios initial_settings, new_settings;
02007 static int peek_character = -1;
02008 static bool runinitonetime = false;
02009 #endif
02010
02011 #ifdef PLF_SYSTEM_NIOS2
02012 static int peek_character = -1;
02013 static int fd_initialized = 0;
02014 static int unix_fd=0;
02015 static FILE* stream_fd;
02016 #endif
02017
02018
02019
02020
02021
02022
02023 void platformInitializeConsoleInput()
02024 {
02025 #if defined(PLF_SYSTEM_SOLARIS) || defined(PLF_SYSTEM_LINUX)
02026 fflush(stdout);
02027
02028 if (runinitonetime == false)
02029 {
02030 tcgetattr(0,&initial_settings);
02031 runinitonetime = true;
02032 }
02033
02034 tcgetattr(0, &new_settings);
02035 new_settings.c_lflag &= ~ICANON;
02036 new_settings.c_lflag &= ~ECHO;
02037 new_settings.c_lflag &= ~ISIG;
02038 new_settings.c_cc[VMIN] = 1;
02039 new_settings.c_cc[VTIME] = 0;
02040 tcsetattr(0, TCSANOW, &new_settings);
02041 #endif
02042
02043 #ifdef PLF_SYSTEM_NIOS2
02044 if (fd_initialized == 0)
02045 {
02046 fd_initialized = 1;
02047
02048 unix_fd = open("/dev/uart1", O_NONBLOCK | O_RDWR);
02049 stream_fd = fdopen(unix_fd, "rw");
02050 }
02051 #endif
02052 }
02053
02054 void platformDeinitializeConsoleInput()
02055 {
02056 #if defined(PLF_SYSTEM_SOLARIS) || defined(PLF_SYSTEM_LINUX)
02057 if (runinitonetime == true) tcsetattr(0, TCSANOW, &initial_settings);
02058 #endif
02059
02060 #ifdef PLF_SYSTEM_NIOS2
02061 if (fd_initialized == 1)
02062 {
02063 fclose(stream_fd);
02064
02065
02066 fd_initialized = 0;
02067 }
02068 #endif
02069 }
02070
02071
02072
02073 INT32 platformgetch()
02074 {
02075 #if defined(PLF_SYSTEM_SOLARIS) || defined(PLF_SYSTEM_LINUX)
02076 char ch;
02077
02078 if(peek_character != -1)
02079 {
02080 ch = peek_character;
02081 peek_character = -1;
02082 return ch;
02083 }
02084 read(0,&ch,1);
02085 return ch;
02086 #endif
02087
02088 #ifdef PLF_SYSTEM_WINNT
02089
02090 return( getch() );
02091
02092 #endif
02093
02094 #ifdef PLF_SYSTEM_NIOS2
02095 int my_char;
02096
02097 if(peek_character != -1)
02098 {
02099 my_char = peek_character;
02100 peek_character = -1;
02101 return my_char;
02102 }
02103
02104 my_char = getc(stream_fd);
02105 clearerr(stream_fd);
02106
02107 if (my_char == EOF) return -1; else return my_char;
02108 #endif
02109 }
02110
02111
02112
02113 INT32 platformkbhit()
02114 {
02115 #if defined(PLF_SYSTEM_SOLARIS) || defined(PLF_SYSTEM_LINUX)
02116 unsigned char ch;
02117 int nread;
02118
02119 if (peek_character != -1) return 1;
02120 new_settings.c_cc[VMIN]=0;
02121 tcsetattr(0, TCSANOW, &new_settings);
02122 nread = read(0,&ch,1);
02123 new_settings.c_cc[VMIN]=1;
02124 tcsetattr(0, TCSANOW, &new_settings);
02125
02126 if(nread == 1)
02127 {
02128 peek_character = ch;
02129 return 1;
02130 }
02131 return 0;
02132 #endif
02133
02134 #ifdef PLF_SYSTEM_WINNT
02135 return( kbhit() );
02136 #endif
02137
02138 #ifdef PLF_SYSTEM_NIOS2
02139 int my_char;
02140
02141 if(peek_character != -1) return 1;
02142
02143 my_char = getc(stream_fd);
02144 clearerr(stream_fd);
02145
02146 peek_character = -1;
02147
02148 if (my_char != EOF)
02149 {
02150 peek_character = my_char;
02151 return 1;
02152 }
02153
02154 return 0;
02155 #endif
02156 }
02157
02158
02159 #ifdef PLF_ENDIANCHANGE
02160
02161
02162
02163
02164 void platform_put_double_at( UINT8 *p_bufpos, DOUBLE data )
02165 {
02166 UINT8 *datap = (UINT8 *) &data;
02167 UINT8 *bufpos = (UINT8 *) p_bufpos;
02168
02169 bufpos[0] = datap[7];
02170 bufpos[1] = datap[6];
02171 bufpos[2] = datap[5];
02172 bufpos[3] = datap[4];
02173 bufpos[4] = datap[3];
02174 bufpos[5] = datap[2];
02175 bufpos[6] = datap[1];
02176 bufpos[7] = datap[0];
02177 }
02178
02179
02180 DOUBLE platform_get_double_at( UINT8 *p_bufpos )
02181 {
02182 DOUBLE dataloc;
02183 UINT8 *locp = (UINT8 *) &dataloc;
02184 UINT8 *bufpos = (UINT8 *) p_bufpos;
02185
02186 locp[7] = bufpos[0];
02187 locp[6] = bufpos[1];
02188 locp[5] = bufpos[2];
02189 locp[4] = bufpos[3];
02190 locp[3] = bufpos[4];
02191 locp[2] = bufpos[5];
02192 locp[1] = bufpos[6];
02193 locp[0] = bufpos[7];
02194
02195 return dataloc;
02196 }
02197
02198
02199 void platform_put_float_at( UINT8 *p_bufpos, FLOAT data )
02200 {
02201 UINT8 *datap = (UINT8 *) &data;
02202 UINT8 *bufpos = (UINT8 *) p_bufpos;
02203
02204 bufpos[0] = datap[3];
02205 bufpos[1] = datap[2];
02206 bufpos[2] = datap[1];
02207 bufpos[3] = datap[0];
02208 }
02209
02210
02211 FLOAT platform_get_float_at( UINT8 *p_bufpos )
02212 {
02213 FLOAT dataloc;
02214 UINT8 *locp = (UINT8 *) &dataloc;
02215 UINT8 *bufpos = (UINT8 *) p_bufpos;
02216
02217 locp[3] = bufpos[0];
02218 locp[2] = bufpos[1];
02219 locp[1] = bufpos[2];
02220 locp[0] = bufpos[3];
02221
02222 return dataloc;
02223 }
02224
02225
02226 void platform_put_uint16_at( UINT8 *p_bufpos, UINT16 data )
02227 {
02228 UINT8 *datap = (UINT8 *) &data;
02229 UINT8 *bufpos = (UINT8 *) p_bufpos;
02230
02231 bufpos[0] = datap[1];
02232 bufpos[1] = datap[0];
02233 }
02234
02235
02236 UINT16 platform_get_uint16_at( UINT8 *p_bufpos )
02237 {
02238 UINT16 dataloc;
02239 UINT8 *locp = (UINT8 *) &dataloc;
02240 UINT8 *bufpos = (UINT8 *) p_bufpos;
02241
02242 locp[1] = bufpos[0];
02243 locp[0] = bufpos[1];
02244
02245 return dataloc;
02246 }
02247
02248
02249 void platform_put_uint32_at( UINT8 *p_bufpos, UINT32 data )
02250 {
02251 UINT8 *datap = (UINT8 *) &data;
02252 UINT8 *bufpos = (UINT8 *) p_bufpos;
02253
02254 bufpos[0] = datap[3];
02255 bufpos[1] = datap[2];
02256 bufpos[2] = datap[1];
02257 bufpos[3] = datap[0];
02258 }
02259
02260
02261 UINT32 platform_get_uint32_at( UINT8 *p_bufpos )
02262 {
02263 UINT32 dataloc;
02264 UINT8 *locp = (UINT8 *) &dataloc;
02265 UINT8 *bufpos = (UINT8 *) p_bufpos;
02266
02267 locp[3] = bufpos[0];
02268 locp[2] = bufpos[1];
02269 locp[1] = bufpos[2];
02270 locp[0] = bufpos[3];
02271
02272 return dataloc;
02273 }
02274
02275
02276 void platform_put_uint8_at( UINT8 *p_bufpos, UINT8 data )
02277 {
02278 *((UINT8 *) p_bufpos) = data;
02279 }
02280
02281
02282 UINT8 platform_get_uint8_at( UINT8 *p_bufpos )
02283 {
02284 return *((UINT8 *) p_bufpos);
02285 }
02286
02287
02288 void platform_put_int16_at( UINT8 *p_bufpos, INT16 data )
02289 {
02290 UINT8 *datap = (UINT8 *) &data;
02291 UINT8 *bufpos = (UINT8 *) p_bufpos;
02292
02293 bufpos[0] = datap[1];
02294 bufpos[1] = datap[0];
02295 }
02296
02297
02298 INT16 platform_get_int16_at( UINT8 *p_bufpos )
02299 {
02300 INT16 dataloc;
02301 UINT8 *locp = (UINT8 *) &dataloc;
02302 UINT8 *bufpos = (UINT8 *) p_bufpos;
02303
02304 locp[1] = bufpos[0];
02305 locp[0] = bufpos[1];
02306
02307 return dataloc;
02308 }
02309
02310
02311 void platform_put_int32_at( UINT8 *p_bufpos, INT32 data )
02312 {
02313 UINT8 *datap = (UINT8 *) &data;
02314 UINT8 *bufpos = (UINT8 *) p_bufpos;
02315
02316 bufpos[0] = datap[3];
02317 bufpos[1] = datap[2];
02318 bufpos[2] = datap[1];
02319 bufpos[3] = datap[0];
02320 }
02321
02322
02323 INT32 platform_get_int32_at( UINT8 *p_bufpos )
02324 {
02325 INT32 dataloc;
02326 UINT8 *locp = (UINT8 *) &dataloc;
02327 UINT8 *bufpos = (UINT8 *) p_bufpos;
02328
02329 locp[3] = bufpos[0];
02330 locp[2] = bufpos[1];
02331 locp[1] = bufpos[2];
02332 locp[0] = bufpos[3];
02333
02334 return dataloc;
02335 }
02336
02337
02338 void platform_put_int8_at( UINT8 *bufpos, INT8 data )
02339 {
02340 *((INT8 *) bufpos) = data;
02341 }
02342
02343
02344 INT8 platform_get_int8_at( UINT8 *bufpos )
02345 {
02346 return *((INT8 *) bufpos);
02347 }
02348
02349 #endif // PLF_ENDIANCHANGE