📄 simulate.c
字号:
}
#ifdef WIN95
Sleep(1000);
#endif
if (system_data.NetServer[0].FatherSocket == 0)
{
system_data.NetServer[0].ThreadHandle = 0;
}
if (system_data.NetServer[0].ThreadHandle == 0)
{
FsmPrintf("\r\nStart Fsm Server Fail,maybe %d port is in use",port);
}
else
{
FsmPrintf("\r\nSocket[%d] is listening on port %d\r\n",
system_data.NetServer[0].FatherSocket,port);
}
}
return 0;
}
int CreatePhyTread(int ThreadType,int SocketID)
{
int i;
uint32 ThreadID;
HANDLE ThreadHandle;
for(i = 0; i < MAX_THREAD_NUM; i++)
{
if(system_data.TreadCtrl_t[i].IsUsed == 0)
{
system_data.TreadCtrl_t[i].IsUsed = 1;
break;
}
}
if(i == MAX_THREAD_NUM)
{
return 1; //error
}
ThreadHandle = (HANDLE)CreatePhysicalThread(PhysicalThread,0,&ThreadID);
system_data.TreadCtrl_t[i].ThreadID = ThreadID;
system_data.TreadCtrl_t[i].SocketID = SocketID;
system_data.TreadCtrl_t[i].ThreadType = ThreadType;
ResumeThread(ThreadHandle);
return 0;
}
int NetClientConnectScan()
{
int i;
int socket_id;
struct NETSERVERCTL_t * q;
for (i = 0; i < 2; i++)
{
q = &system_data.NetServer[i];
if (q[0].Head == q[0].Tail)
{
continue;
}
socket_id = q[0].ChildSocket[q[0].Tail];
q[0].Tail++;
SendStream(socket_id,"Hello",8);
printf("\r\nSocket %d is Opened\r\n",socket_id);
if (q[0].Tail >= 8) q[0].Tail = 0;
if(CreatePhyTread(THREADTYPE_SOCKET,socket_id) != 0)
{
CloseSocket(socket_id);
}
}
return 0;
}
/*******************************************************
*
* Delay This Thread to Relinquish The Occupy of CPU
* (Can Include Some More OS)
* second: Delay Time in Second
*
*******************************************************/
void taskDelay(int second)
{
#ifdef WIN95
Sleep(second*10);
#endif
return;
}
/**********************************************
*
* Transform String From Lower to Uper
*
**********************************************/
int my_strupr(char s[])
{
char c;
int i;
for (i = 0; (c = s[i]) != 0; i++)
{
if (c >= 'a' && c <= 'z')
{
s[i] = c - ('a' - 'A');
}
}
return 0;
}
int my_strlwr(char s[])
{
uint8 c;
int i;
for (i = 0; (c = s[i]) != 0; i++)
{
if (c >= 'A' && c <= 'Z')
{
s[i] = c + ('a' - 'A');
}
}
return 0;
}
/**************************************************************
*
* Transform String From External ASCIIZ to Internal BIN Code
* (把外部 ASCIIZ 码数变成内部 BIN 数)
*
**************************************************************/
int my_atoi(char s[])
{
unsigned x,base;
unsigned char c;
c = s[0];
if ((c < '0') || (c > '9'))
{
return 0;
}
base=10;
x=0;
if ((s[1] == 'x') || (s[1] == 'X')) // 0x 表示 16 进制
{
s += 2;
base = 16;
}
else if ((s[1] == 'o') || (s[1] == 'O')) // 0o 表示 8 进制
{
s += 2;
base=8;
}
else if ((s[1] == 'b') || (s[1] == 'B')) // 0b 表示 2 进制
{
s += 2;
base = 2;
}
while ((c = *s++) != 0 ) // 进行变换
{
if ((c >= 'a') && (c <= 'z'))
{
c -= 'a' - 'A';
}
c -= '0';
if (c > 9)
{
c -= 7;
}
x = (x * base + c);
}
return x;
}
/**************************************************************
*
* 功能: 把用空格分隔的串分成若干子串
* 输入: s[] 是待分割的串
* 输出: pos[0],pos[1],pos[2] 是各子串串首在 s[] 中的位置
* 返回: 子串个数
*
**************************************************************/
int SplitLineBySpace(char s[],int pos[])
{
int state,len,i;
char c,d;
i = 0;
state = 0;
c = d = 0;
for (len = 0; (c = s[len]) != 0; len++)
{
switch(state)
{
case 0:
if ((c <= ' ') || (c == ',') || (c == ';'))
{
continue;
}
pos[i++] = len;
state = 2;
d = c;
if ((c == 0x27) || (c == '"'))
{
state = 1;
}
break;
case 1:
if (c != d)
{
continue;
}
if (s[len + 1])
{
s[len + 1] = 0;
len++;
}
state = 0;
break;
case 2:
if ((c <= ' ') || (c == ',') || (c == ';'))
{
s[len] = 0;
state = 0;
}
break;
}
}
return i;
}
/**************************************************************
*
* 功能: 把用斜线分隔的串分成若干子串
* 输入: s[] 是待分割的串
* 输出: pos[0],pos[1],pos[2] 是各子串串首在 s[] 中的位置
* 返回: 子串个数
*
**************************************************************/
int SplitPathBySlash(char s[],int pos[])
{
uint32 i;
uint32 j = 1;
pos[0] = 0;
for(i = 1; i <= strlen(s); i++)
{
if((*(s+i) == '/') || (*(s+i) == '\\'))
{
pos[j] = i;
j++;
}
}
pos[j+1] = strlen(s);
return j;
}
/**************************************************************
*
* 功能: 从 " 或 ' 括起来的串中取内容
* 入口： s[] 带 " 或 ' 的串
* 出口： p[] 不带引号的串
* 返回值：0
*
**************************************************************/
int GetContentFromDoubleQuto(char p[],char s[],int s_len)
{
int i;
char d;
d = s[0]; // "或者'
// for (i=1;(c=s[i])!=0;i++)
for (i = 1; i < s_len; i++)
{
if (s[i] == d)
{
break;
}
else
{
p[i - 1] = s[i];
}
p[i - 1] = 0;
}
return i;
}
/**************************************************************
*
* 功能:从一个带引号（" 或 '）或不带引号的串中取出内容填入p中，
* 如果p_len-1<s_len,则截取s中前p_len-1个字符填入。
* 入口： p[] 带或不带引号（" 或 '）的串
* p_len p[]的长度
* s[] 带或不带引号（" 或 '）的串
* s_len s[]的长度，含结尾的 \0
* 出口：
* p[] 不带引号的串
* 返回值：实际拷贝长度
*
**************************************************************/
int HighGetContentFromDoubleQuto(char p[],int p_len,char s[],int s_len)
{
char c;
c = s[0];
if ((c == '\'') || (c == '\"')) // 若首字符是引号就剥去引号
{
if (s_len > p_len)
{
s_len = p_len;
}
return GetContentFromDoubleQuto(p,s,s_len);
}
if(s_len > p_len-1)
{
s_len = p_len-1;
}
memcpy(p,s,s_len); // 否则就直接拷贝
p[s_len + 1] = 0;
return s_len;
}
/**********************************************
*
* Get Device Name From File Full Path String
* Found return 0
* Not Found return -1
*
**********************************************/
int GetDeviceNameFromString(BYTE *DevName,int Name_len,const char * path,int path_len)
{
uint8 *s1;
uint8 *s2;
int pos = 0;
if((path_len == 0) || (strlen(path) == 0))
{
return -1;
}
s1 = strstr(path,"/");
if(s1 != NULL)
{
s2 = strstr(s1 + 1,"/");
if(s2 != NULL)
{
pos = s2 - s1 + 1;
if(pos > Name_len)
{
pos = Name_len;
}
memcpy(DevName,s1,pos);
return 0;
}
}
return -1;
}
/**********************************************
*
* Find Specify Device In System Devices List
* Found return DeviceNum
* Not Found return -1
*
**********************************************/
int FsmDevFind(const char * name)
{
uint8 name_t[128];
int i = 1;
int DeviceDescFreeFlag = 0;
memset(name_t,0,sizeof(name_t));
i = GetDeviceNameFromString(name_t,sizeof(name_t),name,(strlen(name)+1));
if(i != 0) return -1; //errocode
for(i = 0; i < MAX_MOUNT_DEVICE; i++)
{
if(strcmp(Volume_Array[i].VolName,name_t) == 0)
{
DeviceDescFreeFlag = 1;
break;
}
}
if(DeviceDescFreeFlag == 1) //该设备已安装
{
return i;
}
else
{
return -1; //errocode
}
}
int CMD_QUIT(char s[],int pos[],int value[],int Segment)
{
// system_data.QuitMode = 0;
return -1;
}
int CMD_VER(char s[],int pos[],int value[],int Segment)
{
FsmPrintf("\r\nTEST VERSION:1.0.2 DATE:2003.08.25");
return 0;
}
uint32 test()
{
char * buf;
char temp;
buf = 0;
temp = buf[0];
return -1;
}
int CMD_RECLTEST(char s[],int pos[],int value[],int Segment)
{
return 0;
}
int OpenWinDowsFile(char * name,int mode)
{
// FS_HANDLE FreeHandle,LowerFD;
// if(name == NULL || strlen(name) > MAX_PATH_LENGTH)
// {
// return -1; //errocode
// }
// Sem_Take(_VFS_FD_Lock);
//Is there a free file descriptor?
// for( FreeHandle = 0; FreeHandle < MAX_FILE_OPEN; FreeHandle++ )
// {
// if(VFD_Array[FreeHandle].Flag == 0)
// {
// VFD_Array[FreeHandle].Flag = 1;
// break;
// }
// }
// if(FreeHandle >= MAX_FILE_OPEN) //No Free VFS File Descriptor
// {
// Sem_Give(_VFS_FD_Lock);
// return -1;
// }
return (int)fopen(name,(mode==0) ? "rb" : (mode==2) ? "wb" : "rb+");
// LowerFD = (int)fopen(name,(mode==0) ? "rb" : (mode==2) ? "wb" : "rb+");
// if(LowerFD <= 0)
// {
// return -1; //errorcode
// }
// if((strlen(name) + 1) > MAX_PATH_LENGTH)
// return -1;
// memset(&VFD_Array[FreeHandle],0,sizeof(VFD_Array[FreeHandle]));
// memcpy(VFD_Array[FreeHandle].FileName, name, strlen(name) + 1);
// VFD_Array[FreeHandle].AccessMode = mode;
// VFD_Array[FreeHandle].LowerFdIdx = LowerFD;
// VFD_Array[FreeHandle].VolumeP = 0;
// GetFileInfoFromLowerFD(LowerFD,&VFD_Array[FreeHandle].FileInfo)
// VFD_Array[FreeHandle].FileInfo = ;
// Sem_Give(_VFS_FD_Lock);
// return FreeHandle;
}
int SeekWinDowsFile(int fd,int pos,int mode)
{
return fseek( (FILE *)fd, pos, mode);
}
int TellWinDowsFile(int fd)
{
return ftell( (FILE *)fd );
}
/*---------------------------------------------------*/
/* 关闭一个文件*/
/* 输入： handle 文件句柄*/
/* 返回： 0 成功 1 失败*/
/*---------------------------------------------------*/
int CloseWinDowsFile(int handle)
{
int CloseSuccessFlag = 0;
/*
if ((handle < SIM_FD_MIN) && (handle > SIM_MAX_FILE)) //fd is valid ?
return 1;
*/
CloseSuccessFlag = fclose((FILE *)(handle));
if (CloseSuccessFlag == 0)
{
// Sem_Take(_VFS_FD_Lock);
// memset(&VFD_Array[handle],0,sizeof(VFD_Array[handle]));
// Sem_Give(_VFS_FD_Lock);
}
return CloseSuccessFlag;
}
/*---------------------------------------------------*/
/* 写一个文件*/
/* 输入： handle 文件句柄*/
/* buf 待写的字符串*/
/* len 串长*/
/* 返回： 实际写入的串长*/
/*---------------------------------------------------*/
int WriteWinDowsFile(int handle,const void * buf,int len)
{
return fwrite(buf,1,len,(FILE *)handle);
}
/*---------------------------------------------------*/
/* 读一个文件*/
/* 输入： handle 文件句柄*/
/* buf 待写的字符串*/
/* len 串长*/
/* 返回： 实际写入的串长*/
/*---------------------------------------------------*/
int ReadWinDowsFile(int handle,char * buf,int len)
{
return fread(buf,1,len,(FILE *)handle);
}
int DeleteWinDowsFile(char * name)
{
return remove(name);
}
uint32 AllocSimFd()
{
uint32 i;
for(i = 0; i < SIM_MAX_FILE; i++)
{
if(SimFd_t[i].IsUsed == 0)
{
SimFd_t[i].IsUsed = 1;
return i;
}
}
return i;
}
int OpenAllFile(char * name,int mode)
{
uint32 SimFd;
int status;
SimFd = AllocSimFd();
if(SimFd == SIM_MAX_FILE)
{
return -1; //error
}
if(strncmp(name,VOLNAME,strlen(VOLNAME)) == 0)
{
SimFd_t[SimFd].FileType = FSM;
status = FsmOpen(name,mode);
if(status < 0)
{
memset(&SimFd_t[SimFd],0,sizeof(SimFd_t[SimFd]));
return -1; //error
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -