Example #1
0
void
DeviceDescriptor::AutoReopen(OperationEnvironment &env)
{
  if (IsAltair() || !config.IsAvailable() || config.IsServer() ||
      IsConnected() || (driver != NULL && !driver->HasTimeout()) ||
      /* attempt to reopen a failed device every 30 seconds */
      !reopen_clock.CheckUpdate(30000))
    return;

  TCHAR buffer[64];
  LogStartUp(_T("Reconnecting to device %s"), config.GetPortName(buffer, 64));

  InputEvents::processGlideComputer(GCE_COMMPORT_RESTART);
  Reopen(env, false);
}
Example #2
0
NS_IMETHODIMP
nsFileInputStream::Seek(PRInt32 aWhence, PRInt64 aOffset)
{
    PR_FREEIF(mLineBuffer); // this invalidates the line buffer
    if (!mFD) {
        if (mBehaviorFlags & REOPEN_ON_REWIND) {
            nsresult rv = Reopen();
            if (NS_FAILED(rv)) {
                return rv;
            }
        } else {
            return NS_BASE_STREAM_CLOSED;
        }
    }

    return nsFileStream::Seek(aWhence, aOffset);
}
Example #3
0
wxInputStream *ArcApp::MakeInputStream()
{
    wxFFileInputStream *strm;

    if (m_filter) {
        Reopen("rb", stdin);
        strm = new wxFFileInputStream(stdin);
    }
    else {
        strm = new wxFFileInputStream(m_archive);
    }

    if (strm->Ok())
        return strm;

    delete strm;
    return NULL;
}
Example #4
0
bool IOCtlSrc::DiscReady()
{
    if (m_device == INVALID_HANDLE_VALUE)
        return false;

    DWORD unused;
    if (DeviceIoControl(m_device, IOCTL_STORAGE_CHECK_VERIFY, nullptr, 0,
                        nullptr, 0, &unused, nullptr)) {
        if (!m_sectors)
            Reopen();
    } else {
        m_sectors = 0;
        m_layer_break = 0;
        m_media_type = 0;
    }

    return !!m_sectors;
}
Example #5
0
void
DeviceDescriptor::AutoReopen(OperationEnvironment &env)
{
  assert(InMainThread());

  if (/* don't reopen a device that is occupied */
      IsOccupied() ||
      !config.IsAvailable() ||
      !ShouldReopen() ||
      /* attempt to reopen a failed device every 30 seconds */
      !reopen_clock.CheckUpdate(30000))
    return;

  TCHAR buffer[64];
  LogStartUp(_T("Reconnecting to device %s"), config.GetPortName(buffer, 64));

  InputEvents::processGlideComputer(GCE_COMMPORT_RESTART);
  Reopen(env);
}
Example #6
0
wxOutputStream *ArcApp::MakeOutputStream()
{
    if (m_filter) {
        m_info = &std::cerr;
        Reopen("wb", stdout);
        wxFFileOutputStream *strm = new wxFFileOutputStream(stdout);
        if (strm->Ok())
            return strm;
        delete strm;
        return NULL;
    }
    else {
        wxOutputStream *strm = new wxTempFileOutputStream(m_archive);
        if (strm->IsOk())
            return strm;
        delete strm;
        return NULL;
    }
}
Example #7
0
void RFile::seek2(DWORD pos, DWORD how)
{
    DWORD np;
    if ((np = SetFilePointer(m_fh, pos, NULL, how)) == 0xffffffff)
    {
        if (GetLastError() == 1617)
        {
            if (!Reopen())
            {
                AfxMessageBox(_T("Can't reopen file."), MB_ICONERROR | MB_OK, 0);
                return;
            }
            if ((np = SetFilePointer(m_fh, pos, NULL, how)) == 0xffffffff)
                ShowError();
        }
        else
            ShowError();
    }
    if (np != 0xffffffff)
        m_ptr = np;
}
Example #8
0
DWORD RFile::read2(void *buf, DWORD size)
{
    DWORD rd = 0;

    if (!ReadFile(m_fh, buf, size, &rd, NULL))
    {
        if (GetLastError() == 1617)
        {
            if (!Reopen())
            {
                AfxMessageBox(_T("Can't reopen file."), MB_ICONERROR | MB_OK, 0);
                return 0;
            }
            if (!ReadFile(m_fh, buf, size, &rd, NULL))
                ShowError();
        }
        else
            ShowError();
    }
    m_ptr += rd;
    return rd;
}
Example #9
0
void
DeviceDescriptor::AutoReopen(OperationEnvironment &env)
{
  assert(InMainThread());

  if (/* don't reopen a device that is occupied */
      IsOccupied() ||
      !config.IsAvailable() ||
      !ShouldReopen() ||
      /* attempt to reopen a failed device every 30 seconds */
      !reopen_clock.CheckUpdate(30000))
    return;

#ifdef ANDROID
  if (config.port_type == DeviceConfig::PortType::RFCOMM &&
      android_api_level < 11 && n_failures >= 2) {
    /* on Android < 3.0, system_server's "BT EventLoop" thread
       eventually crashes with JNI reference table overflow due to a
       memory leak after too many Bluetooth failures
       (https://code.google.com/p/android/issues/detail?id=8676);
       don't attempt to reconnect on this Android version over and
       over to keep the chance of this bug occurring low enough */

    if (n_failures == 2) {
      LogFormat(_T("Giving up on Bluetooth device %s to avoid Android crash bug"),
                config.bluetooth_mac.c_str());
      ++n_failures;
    }

    return;
  }
#endif

  TCHAR buffer[64];
  LogFormat(_T("Reconnecting to device %s"), config.GetPortName(buffer, 64));

  InputEvents::processGlideComputer(GCE_COMMPORT_RESTART);
  Reopen(env);
}
Example #10
0
void CFileAutoClose::WriteAt(const void* buffer, uint64 offset, size_t count)
{
	Reopen();
	m_file.Seek(offset);
	m_file.Write(buffer, count);
}
Example #11
0
void CFileAutoClose::ReadAt(void* buffer, uint64 offset, size_t count)
{
	Reopen();
	m_file.Seek(offset);
	m_file.Read(buffer, count);
}
Example #12
0
bool CFileAutoClose::SetLength(uint64 newLength)
{
	Reopen();
	return m_file.SetLength(newLength);
}
Example #13
0
int CFileAutoClose::fd()
{
	Reopen();
	m_locked++;
	return m_file.fd();
}
Example #14
0
bool CFileAutoClose::Eof()
{
	Reopen();
	return m_file.Eof();
}
Example #15
0
File: set.c Project: justid/Zoolu
int upgradeINI(double version, int file_ptr, int pos)
{
void* rebuff_ptr = NULL;
void* buff_prev = NULL;
void* buff_next = NULL;

int size ;
int bytesfree ;
char* Addto ;
BYTE insert_flag = FALSE ;
char Addto113[] = "Current_PLD = \\;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\r\n\r\n" ;
char Addto117[] = "Current_YS = EMP ;\r\nYS1 =  XYF ;\r\nYS2 = BBBB ;\r\nYS3 = CCCC ;\r\nYS4 = DDDD ;\r\nYS5 = EEEE ;\r\nYS6 = FFFF ;\r\nYS7 = GGGG ;\r\nYS8 = HHHH ;\r\n\r\n" ;
char Addto1171[] = "XLTYPE =     1.000 ;\r\nPJMODE =     1.000 ;\r\n" ;
char Addto1172[] = "Current_HP =  EMP ;" ;
char Addto119[] = "\r\n\r\nCurrent_SD = EMP ;\r\nSD1 = AAAA ;\r\nSD2 = BBBB ;\r\nSD3 = CCCC ;\r\nSD4 = DDDD ;\r\nSD5 = EEEE ;\r\nSD6 = FFFF ;\r\nSD7 = GGGG ;\r\nSD8 = HHHH ;" ;

Warning("升级中..",2) ;
file_ptr = Reopen(file_ptr) ;

if (version == 1.11){
	Addto = Addto113 ;
	WriteINI(file_ptr, pos, "Version =     1.130 ;",NOW,TRUE) ;
} else if (version == 1.13){
	Addto = Addto117 ;
	WriteINI(file_ptr, pos, "Version =     1.170 ;",NOW,TRUE) ;	
} else if (version == 1.17){
	Addto = Addto1171 ;
	WriteINI(file_ptr, pos, "Version =     1.171 ;",NOW,TRUE) ;
	insert_flag = TRUE ;	
} else if (version == 1.171){
	Addto = Addto1172 ;
	WriteINI(file_ptr, pos, "Version =     1.172 ;",NOW,TRUE) ;
} else if (version == 1.172){
	Addto = Addto119 ;
	WriteINI(file_ptr, pos, "Version =     1.190 ;",NOW,TRUE) ;
} else {
	Warning("错误的版本号!",2) ;
	return FALSE ;
}

//增加ini文件大小
size = Bfile_GetFileSize(file_ptr) ;
rebuff_ptr = calloc( size+ strlen(Addto),sizeof(char)) ;
if (insert_flag == TRUE){
		buff_prev = calloc( allset.fpos.sk,sizeof(char)) ;	
		buff_next = calloc( size-allset.fpos.sk,sizeof(char)) ;
		if (buff_prev == NULL || buff_next == NULL){
			if (rebuff_ptr != NULL) free(rebuff_ptr) ;
			DebugS("申请内存失败!") ;
			return FALSE ;
		}
}
else if (rebuff_ptr == NULL){
	DebugS("申请内存失败!") ;
	return FALSE ;
}
if (insert_flag == TRUE){
	Bfile_ReadFile(file_ptr,buff_prev,allset.fpos.sk ,-1) ;	//读取前半部分
	Bfile_ReadFile(file_ptr,buff_next,size-allset.fpos.sk ,-1) ;	//读取后半部分	
}
else Bfile_ReadFile(file_ptr,rebuff_ptr,size ,-1) ;

Bfile_CloseFile(file_ptr) ;
Bfile_DeleteFile(configfile) ;


if (Bfile_CreateFile(configfile, size+strlen(Addto)) < 0) {
	if (rebuff_ptr != NULL)	free(rebuff_ptr) ;
	if (buff_prev != NULL)	free(buff_prev) ;
	if (buff_next != NULL)	free(buff_next) ;
	DebugS("创建文件失败\n请重新上传 ") ;
	return FALSE ;
}
file_ptr = Reopen(file_ptr) ;
if (insert_flag == TRUE) {
	strncat(rebuff_ptr,buff_prev,strlen(buff_prev)) ;		//拼接
	strncat(rebuff_ptr,Addto,strlen(Addto)) ;	
	strncat(rebuff_ptr,buff_next,strlen(buff_next)) ;		
}
else strncat(rebuff_ptr,Addto,strlen(Addto)) ;
Bfile_WriteFile(file_ptr,rebuff_ptr,size+strlen(Addto)) ;
		
if (rebuff_ptr != NULL)	free(rebuff_ptr) ;
if (buff_prev != NULL)	free(buff_prev) ;
if (buff_next != NULL)	free(buff_next) ;

Bfile_CloseFile(file_ptr) ;

return TRUE ;	
}
int CSqldalImpl::Execute(const char* sql_query, IO& io, int (*printer)(void*, IO&,bool), const char* p_pkszMode/*=""*/, int p_Timeout/*=10*/ )
{
	pthread_mutex_lock(&m_sqlMut);

	int rc(SQLITE_OK), first(true);
	const char* zLeftOver ;
	sqlite3_stmt *stmt = NULL ;
	int mode = m_mode ; // save current open mode.

	Reopen(p_pkszMode) ;

	time_t takingTooLong=time(NULL)+p_Timeout ;
	LOG("EXEC:[%s]", sql_query);

	
	for( unsigned nRetry=0; sql_query[0] && (rc==SQLITE_OK || (rc==SQLITE_SCHEMA)); ++nRetry)
	{	
		int srv = 0;
		if ( takingTooLong <=time(NULL) )
		{
			WARN("FAIL:unable to run query in %i seconds (%u attempts, last retCode %d:%s). SQL [%s]",
				p_Timeout, nRetry, srv, sqlite3_errmsg(m_pDBConn), sql_query);
			Reopen(intModeToStr(mode));
            pthread_mutex_unlock(&m_sqlMut);
            return 0;
		}

		srv = sqlite3_prepare_v2(m_pDBConn, sql_query, strlen(sql_query), &stmt, &zLeftOver);

		if ( SQLITE_BUSY == srv )
		{
			WARN("sqlite3_prepare_retry:[%d]:[%s]", sqlite3_errcode(m_pDBConn), sqlite3_errmsg(m_pDBConn) );
			usleep(10000) ;// 10ms delay
			if ( SQLITE_OK != sqlite3_finalize(stmt) )
				WARN("FAIL:sqlite3_finalize:[%d]:[%s]", sqlite3_errcode(m_pDBConn), sqlite3_errmsg(m_pDBConn) );
			continue ;
		}
		if ( SQLITE_OK != srv )
		{
			WARN("FAIL:sqlite3_prepare:[%d]:[%s]", sqlite3_errcode(m_pDBConn), sqlite3_errmsg(m_pDBConn) );
			if ( SQLITE_OK != sqlite3_finalize(stmt) )
				WARN("FAIL:sqlite3_finalize:[%d]:[%s]", sqlite3_errcode(m_pDBConn), sqlite3_errmsg(m_pDBConn) );
			Reopen( intModeToStr(mode) ) ;
			pthread_mutex_unlock(&m_sqlMut);
			return 0 ;
		}
		// this happens for a comment or white-space
		if( !stmt )
		{
			sql_query = zLeftOver;
			continue;
		}

		// returned rows
		unsigned rowRetries=0;
		for ( int rv=SQLITE_ROW; rv==SQLITE_ROW ; )
		{
			rv = sqlite3_step(stmt) ;
			if ( SQLITE_ROW == rv )
			{
				printer( stmt, io, first );
				first=false;
				rowRetries=0;
				continue;
			}
			if ( rowRetries >= 100 ) /* Break if we're unable to get a row in one second(100*10ms) */
			{
				WARN("FAIL:sqlite3_step:Unable to retrieve row; query:[%s]", sql_query);
				Reopen( intModeToStr(mode) );
				pthread_mutex_unlock(&m_sqlMut);
				return 0;
			}
			if ( SQLITE_BUSY == rv )
			{
				WARN("FAIL:sqlite3_step:[%d]:[%s]", sqlite3_errcode(m_pDBConn), sqlite3_errmsg(m_pDBConn) );
				usleep(20*1000) ; // 20ms delay
				rv=SQLITE_ROW;
				rowRetries++;
				continue;
			}
			else if ( SQLITE_DONE != rv )
			{
				WARN("FAIL:sqlite3_step:[%d]:[%s]", sqlite3_errcode(m_pDBConn), sqlite3_errmsg(m_pDBConn) );
				usleep(20*1000) ; // 20ms delay
				break;
			}
		}
		sql_query = zLeftOver;
	
		if ( SQLITE_OK != sqlite3_finalize(stmt) )
		{
			WARN("FAIL:sqlite3_finalize:[%d]:[%s]", sqlite3_errcode(m_pDBConn), sqlite3_errmsg(m_pDBConn) );
            Reopen(intModeToStr(mode));
            pthread_mutex_unlock(&m_sqlMut);
            return 0;
		}
	}

	Reopen( intModeToStr(mode) );
	pthread_mutex_unlock(&m_sqlMut);
	if ( true == first ) return 2 ; // the header was not printed
	return 1;
}
Example #17
0
void JTcpServer::Execute()
{
	while(1){
		if( GetTerminateFlag() )
			break;
		
		if( !m_bOpen ){
			Sleep(50);
			continue;
		}
		if( m_sockState == JListener ){
			m_socket = ::socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
			if( m_socket != SOCKET_ERROR ){
				BOOL bRsa = TRUE;
				::setsockopt(m_socket, SOL_SOCKET, SO_REUSEADDR, (const char*)(&bRsa), sizeof(bRsa));
				sockaddr_in sockAddr;
				sockAddr.sin_family = AF_INET;
				sockAddr.sin_addr.s_addr = ::htonl(ADDR_ANY);
				sockAddr.sin_port = ::htons(m_port);
				if( ::bind(m_socket, (sockaddr*)&sockAddr, sizeof(sockAddr)) == SOCKET_ERROR ){
					Reopen();
				}else{
					if( m_port == 0 ){
						sockaddr_in sockAddr;
						int len = sizeof(sockAddr);
						if( ::getsockname(m_socket, (sockaddr*)&sockAddr, &len) != SOCKET_ERROR )
							m_portAuto = ::ntohs(sockAddr.sin_port);
					}
					if( ::listen(m_socket, SOMAXCONN) != SOCKET_ERROR ){
						m_cs.Enter();
						m_sockState = JListening;
						m_cs.Leave();
					}else{
						Reopen();
					}
				}
			}else{
				Reopen();
			}
		}else if( m_sockState == JListening ){
			sockaddr_in sockIn;
			int len = sizeof(sockIn);
			SOCKET sockAccept = ::accept(m_socket, (sockaddr*)&sockIn, &len);
			if( sockAccept != INVALID_SOCKET && sockAccept != NULL ){
				long bufferSize = JSocketBufferSize;
				::setsockopt(sockAccept, SOL_SOCKET, SO_RCVBUF, (const char*)(&bufferSize), sizeof(bufferSize));
				::setsockopt(sockAccept, SOL_SOCKET, SO_SNDBUF, (const char*)(&bufferSize), sizeof(bufferSize));
				JPeerSocket* newSock = new JPeerSocket(sockAccept);
				if( newSock != NULL ){
					newSock->OnRecvData.Attach<JTcpServer>(this, &JTcpServer::ReadData);
					newSock->Open();
					m_cs.Enter();
					m_sockAcpMap[newSock->ThreadId] = newSock;
					m_cs.Leave();
				}				
			}else{
				::closesocket(sockAccept);
			}
		}
	}
	Close();
}
Example #18
0
void JBlockTcpSocket::Execute()
{
	while(1){
		if( GetTerminateFlag() ){
			break;
		}
		if( !m_bOpen ){
			Sleep(50);
			continue;
		}
		if( m_sockState == JCaller ){
			m_socket = ::socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
			if( m_socket != NULL && m_socket != SOCKET_ERROR ){
				BOOL bRsa = TRUE;
				::setsockopt(m_socket, SOL_SOCKET, SO_REUSEADDR, (const char*)&bRsa, sizeof(bRsa));
				long bufferSize = JSocketBufferSize;
				::setsockopt(m_socket, SOL_SOCKET, SO_RCVBUF, (const char*)&bufferSize, sizeof(bufferSize));
				::setsockopt(m_socket, SOL_SOCKET, SO_SNDBUF, (const char*)&bufferSize, sizeof(bufferSize));
				sockaddr_in sockAddrRemote;
				sockAddrRemote.sin_family = AF_INET;
				HOSTENT* hostInfo;
				if( m_ip.empty() )
					hostInfo = ::gethostbyname("127.0.0.1");	
				else
					hostInfo = ::gethostbyname(JStringToString(m_ip).c_str());
				
				if( hostInfo != NULL ){
					sockAddrRemote.sin_addr.s_addr = ((in_addr*)hostInfo->h_addr)->s_addr;
					sockAddrRemote.sin_port = ::htons(m_port);
					if( ::connect(m_socket, (sockaddr*)&sockAddrRemote, sizeof(sockAddrRemote)) != SOCKET_ERROR ){
						m_cs.Enter();
						m_bConnected = true;
						m_sockState = JConnected;
						m_cs.Leave();
					}else{
						Reopen();
					}
				}
			}else{
				Reopen();
			}
		}else if( m_sockState == JListener ){
			m_socket = ::socket(AF_INET, SOL_SOCKET, IPPROTO_IP);
			if( m_socket == NULL || m_socket == SOCKET_ERROR ){
				Reopen();
			}else{
				BOOL bRsa = TRUE;
				::setsockopt(m_socket, SOL_SOCKET, SO_REUSEADDR, (const char*)&bRsa, sizeof(bRsa));
				long bufferSize = JSocketBufferSize;
				::setsockopt(m_socket, SOL_SOCKET, SO_RCVBUF, (const char*)&bufferSize, sizeof(bufferSize));
				::setsockopt(m_socket, SOL_SOCKET, SO_SNDBUF, (const char*)&bufferSize, sizeof(bufferSize));
				sockaddr_in sockAddrLocal;
				sockAddrLocal.sin_family = AF_INET;
				sockAddrLocal.sin_addr.s_addr = ::htonl(ADDR_ANY);
				sockAddrLocal.sin_port = ::htons(m_port);
				if( ::bind(m_socket, (sockaddr*)&sockAddrLocal, sizeof(sockAddrLocal)) != SOCKET_ERROR ){
					sockaddr_in addrLocal;
					int len;
					if( ::getsockname(m_socket, (sockaddr*)&addrLocal, &len) != SOCKET_ERROR ){
						m_portAuto = ::ntohs(addrLocal.sin_port);
					}
					if( ::listen(m_socket, SOMAXCONN) == SOCKET_ERROR ){
						Reopen();
					}else{
						m_cs.Enter();
						m_sockState = JListening;
						m_cs.Leave();
					}					
				}else{
					Reopen();
				}
			}
		}else if( m_sockState == JListening ){
			sockaddr_in sockRemote;
			int len;
			SOCKET sockAccept = ::accept(m_socket, (sockaddr*)&sockRemote, &len);
			if( sockAccept == INVALID_SOCKET || sockAccept == SOCKET_ERROR ){
				::closesocket(sockAccept);
			}else{				
				::shutdown(m_socket, SD_SEND);
				::closesocket(m_socket);
				BOOL bRsa = TRUE;
				::setsockopt(sockAccept, SOL_SOCKET, SO_REUSEADDR, (const char*)&bRsa, sizeof(bRsa));
				long bufferSize = JSocketBufferSize;
				::setsockopt(sockAccept, SOL_SOCKET, SO_RCVBUF, (const char*)&bufferSize, sizeof(bufferSize));
				::setsockopt(sockAccept, SOL_SOCKET, SO_SNDBUF, (const char*)&bufferSize, sizeof(bufferSize));
				m_sockAccept = sockAccept;
				m_cs.Enter();
				m_bConnected = true;
				m_sockState = JConnected;
				m_cs.Leave();
			}
		}
	}
	Close();
}
Example #19
0
IOCtlSrc::IOCtlSrc(decltype(m_filename) filename)
    : m_filename(filename)
{
    if (!Reopen())
        throw std::runtime_error(" * CDVD: Error opening source.\n");
}
Example #20
0
void JTcpSocket::Execute()
{
	while(1)
	{
		if( GetTerminateFlag() ){
			break;
		}
		if( m_sockState == JIdle ){
			Sleep(50);
			continue;
		}

		m_cs.Enter();
		JSocketState state = m_sockState;
		bool isOpen = m_bOpen;
		m_cs.Leave();

		if( !isOpen ){
			Sleep(50);
			continue;
		}
		if( state == JCaller ){			
			m_socket = ::socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
			if( m_socket != NULL && m_socket != SOCKET_ERROR ){
				BOOL bRsa = TRUE;
				::setsockopt(m_socket, SOL_SOCKET, SO_REUSEADDR, (const char*)(&bRsa), sizeof(BOOL));
				long BufferSize = JSocketBufferSize;
				::setsockopt(m_socket, SOL_SOCKET, SO_RCVBUF, (const char*)(&BufferSize), sizeof(long));
				::setsockopt(m_socket, SOL_SOCKET, SO_SNDBUF, (const char*)(&BufferSize), sizeof(long));
				sockaddr_in addr;
				addr.sin_family = AF_INET;
				HOSTENT* hostinfo = NULL; 
				if( m_ip.empty() )
					hostinfo = ::gethostbyname("127.0.0.1");
				else
					hostinfo = ::gethostbyname(JStringToString(m_ip).c_str());
				
				if( hostinfo ){
					addr.sin_addr.s_addr = ((struct in_addr *)hostinfo->h_addr)->s_addr;
					addr.sin_port = ::htons(m_port);
				}
				if( ::connect(m_socket, (const sockaddr*)(&addr), sizeof(addr)) != SOCKET_ERROR ){
					m_cs.Enter();
					m_sockState = JConnected;
					m_bConnected = true;
					m_cs.Leave();
				}else{
					Reopen();
				}
			}else{
				Reopen();
			}
		}
		else if( state == JListener ){
			m_socket = ::socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
			if( m_socket == NULL && m_socket == SOCKET_ERROR ){
				Reopen();
			}
			else{
				BOOL bRsa = TRUE;
				::setsockopt(m_socket, SOL_SOCKET, SO_REUSEADDR, (const char*)(&bRsa), sizeof(BOOL));
				long bufferSize = JSocketBufferSize;
				::setsockopt(m_socket, SOL_SOCKET, SO_RCVBUF, (const char*)(&bufferSize), sizeof(long));
				::setsockopt(m_socket, SOL_SOCKET, SO_SNDBUF, (const char*)(&bufferSize), sizeof(long));
				sockaddr_in addr;
				addr.sin_family = AF_INET;
				addr.sin_port = ::htons(m_port);
				addr.sin_addr.s_addr = ::htonl(ADDR_ANY);
				if( ::bind(m_socket, (LPSOCKADDR)&addr, sizeof(sockaddr_in)) == SOCKET_ERROR ){
					Reopen();
				}
				else{
					sockaddr_in addr;
					int addrSize = sizeof(sockaddr_in);
					if( m_port == 0 && ::getsockname(m_socket, (LPSOCKADDR)&addr, &addrSize) != SOCKET_ERROR )
						m_portAuto = ::ntohs(addr.sin_port);
									
					if( ::listen(m_socket, SOMAXCONN) != SOCKET_ERROR ){
						m_cs.Enter();
						m_sockState = JListening;
						m_cs.Leave();
					}else{
						Reopen();
					}
				}
			}
		}
		else if( state == JListening ){
			sockaddr_in addr;
			int addrSize = sizeof(sockaddr_in);
			SOCKET accept_sock = ::accept(m_socket, (struct sockaddr*)&addr, &addrSize);
			if( accept_sock == INVALID_SOCKET || accept_sock == NULL ){
				::shutdown(accept_sock, SD_SEND);
				::closesocket(accept_sock);
			}else{
				// close listening socket
				::shutdown(m_socket, SD_SEND);
				::closesocket(m_socket);
				m_socket = NULL;

				long bufferSize = JSocketBufferSize;
				::setsockopt(accept_sock, SOL_SOCKET, SO_RCVBUF, (const char*)(&bufferSize), sizeof(long));
				::setsockopt(accept_sock, SOL_SOCKET, SO_SNDBUF, (const char*)(&bufferSize), sizeof(long));
				m_sockAccept = new JPeerSocket(accept_sock);
				if( m_sockAccept != NULL ){
					m_sockAccept->OnRecvData.Attach<JTcpSocket>(this, &JTcpSocket::ReadData);
					m_sockAccept->Open();
					m_cs.Enter();
					m_sockState = JConnected;
					m_bConnected = true;
					m_cs.Leave();
				}
			}
		}
		else if( state == JConnected ){
			if( !m_bListener ){
				char buffer[65535];
				if( IsDataArrived(10) ){
					long recvSize = 0;
					while( IsDataArrived(0) ){
						recvSize = ::recv(m_socket, buffer, 65535*sizeof(TCHAR), 0);
						if( recvSize <= 0 )
							break;
						
						if( OnRecvData && m_sockState == JConnected)
							OnRecvData(buffer, recvSize);
					}
				}else{
					//Sleep(50);
				}
			}else{
				Sleep(50);
			}
		}else{
			Sleep(50);
		}
	}
	//Close();
}