URL https://opencores.org/ocsvn/plasma/plasma/trunk

Subversion Repositories plasma

[/] [plasma/] [trunk/] [kernel/] [netutil.c] - Blame information for rev 315

Go to most recent revision | Details | Compare with Previous | View Log


/*--------------------------------------------------------------------
 * TITLE: Plasma TCP/IP Network Utilities
 * AUTHOR: Steve Rhoads (rhoadss@yahoo.com)
 * DATE CREATED: 4/20/07
 * FILENAME: netutil.c
 * PROJECT: Plasma CPU core
 * COPYRIGHT: Software placed into the public domain by the author.
 *    Software 'as is' without warranty.  Author liable for nothing.
 * DESCRIPTION:
 *    Plasma FTP server and FTP client and TFTP server and client
 *    and Telnet server.
 *--------------------------------------------------------------------*/
#define INCLUDE_FILESYS
#ifdef WIN32
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#define _LIBC
#endif
#include "rtos.h"
#include "tcpip.h"
 
 
//******************* FTP Server ************************
typedef struct {
   IPSocket *socket;
   int ip, port, bytes, done, canReceive;
   FILE *file;
} FtpdInfo;
 
static void FtpdSender(IPSocket *socket)
{
   unsigned char buf[600];
   int i, bytes, bytes2;
   FtpdInfo *info = (FtpdInfo*)socket->userPtr;
 
   if(info == NULL || info->done)
      return;
   fseek(info->file, info->bytes, 0);
   for(i = 0; i < 5; ++i)
   {
      bytes = fread(buf, 1, 512, info->file);
      bytes2 = IPWrite(socket, buf, bytes);
      info->bytes += bytes2;
      if(bytes != bytes2)
         return;
      if(bytes < 512)
      {
         fclose(info->file);
         IPClose(socket);
         info->done = 1;
         IPPrintf(info->socket, "226 Done\r\n");
         return;
      }
   }
}
 
 
static void FtpdReceiver(IPSocket *socket)
{
   unsigned char buf[600];
   int bytes, state = socket->state;
   FtpdInfo *info = (FtpdInfo*)socket->userPtr;
 
   if(info == NULL || info->done)
      return;
   do
   {
      bytes = IPRead(socket, buf, sizeof(buf));
      fwrite(buf, 1, bytes, info->file);
   } while(bytes);
   if(state > IP_TCP)
   {
      fclose(info->file);
      IPClose(socket);
      info->done = 1;
      IPPrintf(info->socket, "226 Done\r\n");
      return;
   }
}
 
 
static void FtpdServer(IPSocket *socket)
{
   uint8 buf[600];
   int bytes;
   int ip0, ip1, ip2, ip3, port0, port1;
   IPSocket *socketOut;
   FtpdInfo *info = (FtpdInfo*)socket->userPtr;
 
   if(socket == NULL)
      return;
   bytes = IPRead(socket, buf, sizeof(buf)-1);
   buf[bytes] = 0;
   //printf("(%s)\n", buf);
   if(socket->userPtr == NULL)
   {
      info = (FtpdInfo*)malloc(sizeof(FtpdInfo));
      if(info == NULL)
         return;
      memset(info, 0, sizeof(FtpdInfo));
      socket->userPtr = info;
      info->socket = socket;
      socket->timeoutReset = 60;
      IPPrintf(socket, "220 Connected to Plasma\r\n");
   }
   else if(strstr((char*)buf, "USER"))
   {
      if(strstr((char*)buf, "PlasmaSend"))
         info->canReceive = 1;
      IPPrintf(socket, "331 Password?\r\n");
   }
   else if(strstr((char*)buf, "PASS"))
   {
      IPPrintf(socket, "230 Logged in\r\n");
   }
   else if(strstr((char*)buf, "PORT"))
   {
      if(info == NULL)
         return;
      sscanf((char*)buf + 5, "%d,%d,%d,%d,%d,%d", &ip0, &ip1, &ip2, &ip3, &port0, &port1);
      info->ip = (ip0 << 24) | (ip1 << 16) | (ip2 << 8) | ip3;
      info->port = (port0 << 8) | port1;
      //printf("ip=0x%x port=%d\n", info->ip, info->port);
      IPPrintf(socket, "200 OK\r\n");
   }
   else if(strstr((char*)buf, "RETR") || strstr((char*)buf, "STOR"))
   {
      char *ptr = strstr((char*)buf, "\r");
      if(ptr)
         *ptr = 0;
      if(info == NULL)
         return;
      info->file = NULL;
      info->bytes = 0;
      info->done = 0;
      if(strstr((char*)buf, "RETR"))
         info->file = fopen((char*)buf + 5, "rb");
      else if(info->canReceive)
         info->file = fopen((char*)buf + 5, "wb");
      if(info->file)
      {
         IPPrintf(socket, "150 File ready\r\n");
         if(strstr((char*)buf, "RETR"))
            socketOut = IPOpen(IP_MODE_TCP, info->ip, info->port, FtpdSender);
         else
            socketOut = IPOpen(IP_MODE_TCP, info->ip, info->port, FtpdReceiver);
         if(socketOut)
            socketOut->userPtr = info;
      }
      else
      {
         IPPrintf(socket, "500 Error\r\n");
      }
   }
   else if(strstr((char*)buf, "QUIT"))
   {
      if(socket->userPtr)
         free(socket->userPtr);
      IPPrintf(socket, "221 Bye\r\n");
      IPClose(socket);
   }
   else if(bytes)
   {
      IPPrintf(socket, "500 Error\r\n");
   }
}
 
 
void FtpdInit(int UseFiles)
{
   (void)UseFiles;
   IPOpen(IP_MODE_TCP, 0, 21, FtpdServer);
}
 
 
//******************* FTP Client ************************
 
typedef struct {
   uint32 ip, port;
   char user[80], passwd[80], filename[80];
   uint8 *buf;
   int size, bytes, send, state;
} FtpInfo;
 
 
static void FtpCallbackTransfer(IPSocket *socket)
{
   int bytes, state = socket->state;
   FtpInfo *info = (FtpInfo*)socket->userPtr;
 
   //printf("FtpCallbackTransfer\n");
   if(info == NULL)
      return;
   bytes = info->size - info->bytes;
   if(info->send == 0)
      bytes = IPRead(socket, info->buf + info->bytes, bytes);
   else
      bytes = IPWrite(socket, info->buf + info->bytes, bytes);
   info->bytes += bytes;
   if(info->bytes == info->size || (bytes == 0 && state > IP_TCP))
   {
      socket->userFunc(info->buf, info->bytes);
      free(info);
      socket->userPtr = NULL;
      IPClose(socket);
   }
}
 
 
static void FtpCallback(IPSocket *socket)
{
   char buf[600];
   FtpInfo *info = (FtpInfo*)socket->userPtr;
   int bytes, value;
 
   bytes = IPRead(socket, (uint8*)buf, sizeof(buf)-1);
   if(bytes == 0)
      return;
   buf[bytes] = 0;
   sscanf(buf, "%d", &value);
   if(bytes > 2)
      buf[bytes-2] = 0;
   //printf("FtpCallback(%d:%s)\n", socket->userData, buf);
   if(value / 100 != 2 && value / 100 != 3)
      return;
   buf[0] = 0;
   switch(socket->userData) {
   case 0:
      sprintf(buf, "USER %s\r\n", info->user);
      socket->userData = 1;
      break;
   case 1:
      sprintf(buf, "PASS %s\r\n", info->passwd);
      socket->userData = 2;
      if(value == 331)
         break;  //possible fall-through
   case 2:
      sprintf(buf, "PORT %d,%d,%d,%d,%d,%d\r\n",
         info->ip >> 24, (uint8)(info->ip >> 16),
         (uint8)(info->ip >> 8), (uint8)info->ip,
         (uint8)(info->port >> 8), (uint8)info->port);
      socket->userData = 3;
      break;
   case 3:
      if(info->send == 0)
         sprintf(buf, "RETR %s\r\n", info->filename);
      else
         sprintf(buf, "STOR %s\r\n", info->filename);
      socket->userData = 4;
      break;
   case 4:
      sprintf(buf, "QUIT\r\n");
      socket->userData = 9;
      break;
   }
   IPWrite(socket, (uint8*)buf, strlen(buf));
   IPWriteFlush(socket);
   if(socket->userData == 9)
      IPClose(socket);
}
 
 
IPSocket *FtpTransfer(uint32 ip, char *user, char *passwd,
                      char *filename, uint8 *buf, int size,
                      int send, void (*callback)(uint8 *data, int size))
{
   IPSocket *socket, *socketTransfer;
   FtpInfo *info;
   uint8 *ptr;
   info = (FtpInfo*)malloc(sizeof(FtpInfo));
   if(info == NULL)
      return NULL;
   strncpy(info->user, user, 80);
   strncpy(info->passwd, passwd, 80);
   strncpy(info->filename, filename, 80);
   info->buf = buf;
   info->size = size;
   info->send = send;
   info->bytes = 0;
   info->state = 0;
   info->port = 2000;
   socketTransfer = IPOpen(IP_MODE_TCP, 0, info->port, FtpCallbackTransfer);
   socketTransfer->userPtr = info;
   socketTransfer->userFunc = callback;
   socket = IPOpen(IP_MODE_TCP, ip, 21, FtpCallback);
   socket->userPtr = info;
   socket->userFunc = callback;
   ptr = socket->headerSend;
   info->ip = IPAddressSelf();
   return socket;
}
 
 
//******************* TFTP Server ************************
 
 
static void TftpdCallback(IPSocket *socket)
{
   unsigned char buf[512+4];
   int bytes, blockNum;
   FILE *file = (FILE*)socket->userPtr;
   bytes = IPRead(socket, buf, sizeof(buf));
   //printf("TfptdCallback bytes=%d\n", bytes);
   if(bytes < 4 || buf[0])
      return;
   if(buf[1] == 1)  //RRQ = Read Request
   {
      if(file)
         fclose(file);
      file = fopen((char*)buf+2, "rb");
      socket->userPtr = file;
      if(file == NULL)
      {
         buf[0] = 0;
         buf[1] = 5;   //ERROR
         buf[2] = 0;
         buf[3] = 0;
         buf[4] = 'X'; //Error string
         buf[5] = 0;
         IPWrite(socket, buf, 6);
         return;
      }
   }
   if(buf[1] == 1 || buf[1] == 4) //ACK
   {
      if(file == NULL)
         return;
      if(buf[1] == 1)
         blockNum = 0;
      else
         blockNum = (buf[2] << 8) | buf[3];
      ++blockNum;
      buf[0] = 0;
      buf[1] = 3;  //DATA
      buf[2] = (uint8)(blockNum >> 8);
      buf[3] = (uint8)blockNum;
      fseek(file, (blockNum-1)*512, 0);
      bytes = fread(buf+4, 1, 512, file);
      IPWrite(socket, buf, bytes+4);
   }
}
 
 
void TftpdInit(void)
{
   IPSocket *socket;
   socket = IPOpen(IP_MODE_UDP, 0, 69, TftpdCallback);
}
 
 
//******************* TFTP Client ************************
 
 
static void TftpCallback(IPSocket *socket)
{
   unsigned char buf[512+4];
   int bytes, blockNum, length;
 
   bytes = IPRead(socket, buf, sizeof(buf));
   if(bytes < 4 || buf[0])
      return;
   blockNum = (buf[2] << 8) | buf[3];
   length = blockNum * 512 - 512 + bytes - 4;
   //printf("TftpCallback(%d,%d)\n", buf[1], blockNum);
   if(length > (int)socket->userData)
   {
      bytes -= length - (int)socket->userData;
      length = (int)socket->userData;
   }
   if(buf[1] == 3) //DATA
   {
      memcpy((uint8*)socket->userPtr + blockNum * 512 - 512, buf+4, bytes-4);
      buf[1] = 4; //ACK
      IPWrite(socket, buf, 4);
      if(bytes-4 < 512)
      {
         socket->userFunc(socket->userPtr, length);
         IPClose(socket);
      }
   }
}
 
 
IPSocket *TftpTransfer(uint32 ip, char *filename, uint8 *buffer, int size,
                       void (*callback)(uint8 *data, int bytes))
{
   IPSocket *socket;
   uint8 buf[512+4];
   int bytes;
   socket = IPOpen(IP_MODE_UDP, ip, 69, TftpCallback);
   socket->userPtr = buffer;
   socket->userData = size;
   socket->userFunc = callback;
   buf[0] = 0;
   buf[1] = 1; //read
   strcpy((char*)buf+2, filename);
   bytes = strlen(filename);
   strcpy((char*)buf+bytes+3, "octet");
   IPWrite(socket, buf, bytes+9);
   return socket;
}
 
 
//******************* Telnet Server ************************
 
#define COMMAND_BUFFER_SIZE 80
#define COMMAND_BUFFER_COUNT 10
static char CommandHistory[400];
static char *CommandPtr[COMMAND_BUFFER_COUNT];
static int CommandIndex;
static TelnetFunc_t *TelnetFuncList;
static int BusyBox(IPSocket *socket, char *command);
 
 
static void TelnetServer(IPSocket *socket)
{
   uint8 buf[COMMAND_BUFFER_SIZE+4];
   char bufOut[COMMAND_BUFFER_SIZE+32];
   int bytes, i, j, length, rc;
   char *ptr, *command = socket->userPtr;
   bytes = IPRead(socket, buf, sizeof(buf)-1);
   if(bytes == 0)
   {
      if(socket->userData)
         return;
      socket->userData = 1;
      socket->userPtr = command = (char*)malloc(COMMAND_BUFFER_SIZE);
      if(command == NULL)
      {
         IPClose(socket);
         return;
      }
      socket->timeoutReset = 300;
      buf[0] = 255; //IAC
      buf[1] = 251; //WILL
      buf[2] = 3;   //suppress go ahead
      buf[3] = 255; //IAC
      buf[4] = 251; //WILL
      buf[5] = 1;   //echo
      strcpy((char*)buf+6, "Welcome to Plasma.\r\n-> ");
      IPWrite(socket, buf, 6+23);
      IPWriteFlush(socket);
      command[0] = 0;
      return;
   }
   if(command == NULL)
      return;
   buf[bytes] = 0;
   length = (int)strlen(command);
   for(j = 0; j < bytes; ++j)
   {
      if(buf[j] == 255)
         return;
      if(buf[j] == 8 || (buf[j] == 27 && buf[j+2] == 'D'))
      {
         if(buf[j] == 27)
            j += 2;
         if(length)
         {
            // Backspace
            command[--length] = 0;
            bufOut[0] = 8;
            bufOut[1] = ' ';
            bufOut[2] = 8;
            IPWrite(socket, (uint8*)bufOut, 3);
         }
      }
      else if(buf[j] == 27)
      {
         // Command History
         if(buf[j+2] == 'A')
         {
            if(++CommandIndex > COMMAND_BUFFER_COUNT)
               CommandIndex = COMMAND_BUFFER_COUNT;
         }
         else if(buf[j+2] == 'B')
         {
            if(--CommandIndex < 0)
               CommandIndex = 0;
         }
         else
            return;
         bufOut[0] = 8;
         bufOut[1] = ' ';
         bufOut[2] = 8;
         for(i = 0; i < length; ++i)
            IPWrite(socket, (uint8*)bufOut, 3);
         command[0] = 0;
         if(CommandIndex && CommandPtr[CommandIndex-1])
            strncat(command, CommandPtr[CommandIndex-1], COMMAND_BUFFER_SIZE-1);
         length = (int)strlen(command);
         IPWrite(socket, (uint8*)command, length);
         j += 2;
      }
      else
      {
         if(length < COMMAND_BUFFER_SIZE-4 || (length <
            COMMAND_BUFFER_SIZE-2 && (buf[j] == '\r' || buf[j] == '\n')))
         {
            IPWrite(socket, buf+j, 1);
            command[length] = buf[j];
            command[++length] = 0;
         }
      }
      ptr = strstr(command, "\r\n");
      if(ptr)
      {
         ptr[0] = 0;
         bufOut[0] = 0;
         length = (int)strlen(command);
         if(command[0] && length < COMMAND_BUFFER_SIZE)
         {
            // Save command in CommandHistory
            memmove(CommandHistory + length + 1, CommandHistory,
               sizeof(CommandHistory) - length - 1);
            strcpy(CommandHistory, command);
            CommandHistory[sizeof(CommandHistory)-1] = 0;
            for(i = COMMAND_BUFFER_COUNT-2; i >= 0; --i)
            {
               if(CommandPtr[i] == NULL || CommandPtr[i] + length + 1 >=
                  CommandHistory + sizeof(CommandHistory))
                  CommandPtr[i+1] = NULL;
               else
                  CommandPtr[i+1] = CommandPtr[i] + length + 1;
            }
            CommandPtr[0] = CommandHistory;
         }
         if(strncmp(command, "help", 4) == 0)
         {
            sprintf((char*)bufOut, "Commands: help, exit, cat, cp, ls, mkdir, rm, flasherase");
            for(i = 0; TelnetFuncList[i].name; ++i)
            {
               strcat((char*)bufOut, ", ");
               strcat((char*)bufOut, TelnetFuncList[i].name);
            }
         }
         else if(strncmp(command, "exit", 4) == 0)
         {
            free(command);
            socket->userPtr = NULL;
            IPClose(socket);
            return;
         }
         else if(command[0])
         {
            strcpy(bufOut, command);
            ptr = strstr(bufOut, " ");
            if(ptr)
               ptr[0] = 0;
            for(i = 0; TelnetFuncList[i].name; ++i)
            {
               if(strcmp(bufOut, TelnetFuncList[i].name) == 0)
               {
                  TelnetFuncList[i].func(socket, command);
                  break;
               }
            }
            bufOut[0] = 0;
            if(TelnetFuncList[i].name == NULL)
            {
               rc = BusyBox(socket, command);
               if(rc)
                  sprintf((char*)bufOut, "Unknown command (%s)", command);
            }
         }
         strcat((char*)bufOut, "\r\n-> ");
         IPPrintf(socket, (char*)bufOut);
         command[0] = 0;
         length = 0;
         CommandIndex = 0;
      }
   }
   IPWriteFlush(socket);
}
 
 
void TelnetInit(TelnetFunc_t *funcList)
{
   IPSocket *socket;
   TelnetFuncList = funcList;
   socket = IPOpen(IP_MODE_TCP, 0, 23, TelnetServer);
}
 
 
//******************* Console ************************
 
static uint8 myBuffer[1024*3];
static IPSocket *socketTelnet;
 
 
//Implements cat, cp, rm, mkdir, ls
int BusyBox(IPSocket *socket, char *command)
{
   FILE *fileIn, *fileOut;
   int bytes, bytes2;
   char bufA[COMMAND_BUFFER_SIZE];
   char bufB[COMMAND_BUFFER_SIZE];
   char bufC[COMMAND_BUFFER_SIZE];
   char bufD[COMMAND_BUFFER_SIZE];
   memset(bufA, 0, sizeof(bufA));
   memset(bufB, 0, sizeof(bufB));
   memset(bufC, 0, sizeof(bufC));
   memset(bufD, 0, sizeof(bufD));
   sscanf(command, "%s %s %s %s", bufA, bufB, bufC, bufD);
   if(strcmp(bufA, "cat") == 0)
   {
      fileIn = fopen(bufB, "r");
      if(fileIn)
      {
         for(;;)
         {
            bytes = fread(bufD, 1, sizeof(bufD), fileIn);
            if(bytes == 0)
               break;
            bytes2 = IPWrite(socket, (uint8*)bufD, bytes);
            if(bytes != bytes2)
               printf("(%d %d) ", bytes, bytes2);
         }
         fclose(fileIn);
      }
      return 0;
   }
   else if(strcmp(bufA, "cp") == 0)
   {
      fileIn = fopen(bufB, "r");
      if(fileIn)
      {
         fileOut = fopen(bufC, "w");
         if(fileOut)
         {
            for(;;)
            {
               bytes = fread(bufD, 1, sizeof(bufD), fileIn);
               if(bytes == 0)
                  break;
               bytes2 = fwrite(bufD, 1, bytes, fileOut);
            }
            fclose(fileOut);
         }
         fclose(fileIn);
      }
      return 0;
   }
   else if(strcmp(bufA, "rm") == 0)
   {
      OS_fdelete(bufB);
      return 0;
   }
   else if(strcmp(bufA, "mkdir") == 0)
   {
      OS_fmkdir(bufB);
      return 0;
   }
   else if(strcmp(bufA, "ls") == 0)
   {
      fileIn = fopen(bufB, "r");
      if(fileIn)
      {
         for(;;)
         {
            bytes = OS_fdir(fileIn, bufD);
            if(bytes)
               break;
            strcat(bufD, "  ");
            IPWrite(socket, (uint8*)bufD, strlen(bufD));
         }
         fclose(fileIn);
      }
      return 0;
   }
#ifdef INCLUDE_FLASH
   else if(strcmp(bufA, "flasherase") == 0)
   {
      strcpy(bufD, "\r\nErasing");
      IPWrite(socket, (uint8*)bufD, strlen(bufD));
      IPWriteFlush(socket);
      strcpy(bufD, ".");
      for(bytes = 1024*128; bytes < 1024*1024*16; bytes += 1024*128)
      {
         IPWrite(socket, (uint8*)bufD, strlen(bufD));
         IPWriteFlush(socket);
         FlashErase(bytes);
      }
      strcpy(bufD, "\r\nMust Reboot\r\n");
      IPWrite(socket, (uint8*)bufD, strlen(bufD));
      IPWriteFlush(socket);
      OS_ThreadSleep(OS_WAIT_FOREVER);
      return 0;
   }
#endif
   return -1;
}
 
 
void TransferDone(uint8 *data, int bytes)
{
   printf("TransferDone(0x%x, %d)\n", data, bytes);
   data[bytes] = 0;
   if(bytes > 500)
      data[500] = 0;
   printf("%s\n", data);
}
 
 
static void ConsoleInfo(IPSocket *socket, char *command)
{
   (void)command;
   IPPrintf(socket, "Steve was here!");
}
 
 
static void ConsoleMath(IPSocket *socket, char *command)
{
   int v1, v2;
   char buf[20], buf2[20];
   (void)socket;
   if(strlen(command) < 6)
   {
      IPPrintf(socket, "Usage: math <number> <operator> <value>\r\n");
      return;
   }
   sscanf(command, "%s%d%s%d", buf, &v1, buf2, &v2);
   if(buf2[0] == '+')
      v1 += v2;
   else if(buf2[0] == '-')
      v1 -= v2;
   else if(buf2[0] == '*')
      v1 *= v2;
   else if(buf2[0] == '/')
   {
      if(v2 != 0)
         v1 /= v2;
   }
   sprintf((char*)myBuffer, "%d", v1);
   IPPrintf(socket, (char*)myBuffer);
}
 
 
void PingCallback(IPSocket *socket)
{
   IPSocket *socket2 = socket->userPtr;
   //printf("Ping Reply\n");
   IPClose(socket);
   if(socket2)
      IPPrintf(socket2, "Ping Reply");
   else
      printf("Ping Reply\n");
}
 
 
static void DnsResultCallback(IPSocket *socket, uint32 ip, void *arg)
{
   char buf[COMMAND_BUFFER_SIZE];
   IPSocket *socketTelnet = arg;
   IPSocket *socketPing;
   (void)socket;
   sprintf(buf,  "ip=%d.%d.%d.%d\r\n",
      (uint8)(ip >> 24), (uint8)(ip >> 16), (uint8)(ip >> 8), (uint8)ip);
   IPPrintf(socketTelnet, buf);
   socketPing = IPOpen(IP_MODE_PING, ip, 0, PingCallback);
   socketPing->userPtr = socketTelnet;
   myBuffer[0] = 'A';
   IPWrite(socketPing, myBuffer, 1);
}
 
 
static void ConsolePing(IPSocket *socket, char *command)
{
   int ip0, ip1, ip2, ip3;
   char buf[20];
   IPSocket *socketPing;
   if('0' <= command[5] && command[5] <= '9')
   {
      sscanf(command, "%s %d.%d.%d.%d", buf, &ip0, &ip1, &ip2, &ip3);
      ip0 = (ip0 << 24) | (ip1 << 16) | (ip2 << 8) | ip3;
      socketPing = IPOpen(IP_MODE_PING, ip0, 0, PingCallback);
      socketPing->userPtr = socket;
      myBuffer[0] = 'A';
      IPWrite(socketPing, myBuffer, 1);
      IPPrintf(socket, "Sent ping");
   }
   else
   {
      IPResolve(command+5, DnsResultCallback, socket);
      IPPrintf(socket, "Sent DNS request");
   }
}
 
 
void ConsoleTransferDone(uint8 *data, int length)
{
   data[length] = 0;
   IPPrintf(socketTelnet, "Transfer Done");
}
 
 
static void ConsoleFtp(IPSocket *socket, char *command)
{
   char buf[40], user[40], passwd[40], name[COMMAND_BUFFER_SIZE];
   int ip0, ip1, ip2, ip3;
   if(strlen(command) < 10)
   {
      IPPrintf(socket, "ftp #.#.#.# User Password File");
      return;
   }
   sscanf(command, "%s %d.%d.%d.%d %s %s %s",
      buf, &ip0, &ip1, &ip2, &ip3, user, passwd, name);
   ip0 = (ip0 << 24) | (ip1 << 16) | (ip2 << 8) | ip3;
   socketTelnet = socket;
   FtpTransfer(ip0, user, passwd, name, myBuffer, sizeof(myBuffer)-1,
      0, ConsoleTransferDone);
}
 
 
static void ConsoleTftp(IPSocket *socket, char *command)
{
   char buf[COMMAND_BUFFER_SIZE], name[80];
   int ip0, ip1, ip2, ip3;
   if(strlen(command) < 10)
   {
      IPPrintf(socket, "tftp #.#.#.# File");
      return;
   }
   sscanf(command, "%s %d.%d.%d.%d %s",
      buf, &ip0, &ip1, &ip2, &ip3, name);
   ip0 = (ip0 << 24) | (ip1 << 16) | (ip2 << 8) | ip3;
   socketTelnet = socket;
   TftpTransfer(ip0, name, myBuffer, sizeof(myBuffer)-1, ConsoleTransferDone);
}
 
 
static void ConsoleShow(IPSocket *socket, char *command)
{
   (void)command;
   IPPrintf(socket, (char*)myBuffer);
}
 
 
static void ConsoleClear(IPSocket *socket, char *command)
{
   (void)socket;
   (void)command;
   memset(myBuffer, 0, sizeof(myBuffer));
}
 
 
static void ConsoleMkfile(IPSocket *socket, char *command)
{
   OS_FILE *file;
   (void)command;
   file = fopen("myfile.txt", "w");
   fwrite("Hello World!", 1, 12, file);
   fclose(file);
   IPPrintf(socket, "Created myfile.txt");
}
 
 
#ifdef DLL_SETUP
#define DLL_ADDRESS 0x10100000
#include "dll.h"
static void ConsoleRun(IPSocket *socket, char *command)
{
   OS_FILE *file;
   char buf[COMMAND_BUFFER_SIZE], name[80], arg0[80], arg1[80];
   int bytes;
   DllFunc funcPtr;
 
   memset(arg0, 0, sizeof(arg0));
   memset(arg1, 0, sizeof(arg1));
   sscanf(command, "%s %s %s %s", buf, name, arg0, arg1);
   file = fopen(name, "r");
   if(file == NULL)
   {
      IPPrintf(socket, "Can't find %s", name);
      return;
   }
   memset((void*)DLL_ADDRESS, 0, 1024*256);
   bytes = fread((uint8*)DLL_ADDRESS, 1, 1024*1024*8, file);
   fclose(file);
   funcPtr = (DllFunc)DLL_ADDRESS;
   funcPtr(DllFList, socket, arg0, arg1);
}
#endif
 
 
static TelnetFunc_t MyFuncs[] = {
   {"info", 0, ConsoleInfo},
   {"math", 0, ConsoleMath},
   {"ping", 0, ConsolePing},
   {"ftp", 0, ConsoleFtp},
   {"tftp", 0, ConsoleTftp},
   {"show", 0, ConsoleShow},
   {"clear", 0, ConsoleClear},
   {"mkfile", 0, ConsoleMkfile},
#ifdef DLL_SETUP
   {"run", 0, ConsoleRun},
#endif
   {NULL, 0, NULL}
};
 
 
void ConsoleInit(void)
{
   FtpdInit(1);
   TftpdInit();
   TelnetInit(MyFuncs);
}

Line No.	Rev	Author	Line
1	210	rhoads	`/*--------------------------------------------------------------------`
2			`* TITLE: Plasma TCP/IP Network Utilities`
3			`* AUTHOR: Steve Rhoads (rhoadss@yahoo.com)`
4			`* DATE CREATED: 4/20/07`
5			`* FILENAME: netutil.c`
6			`* PROJECT: Plasma CPU core`
7			`* COPYRIGHT: Software placed into the public domain by the author.`
8			`* Software 'as is' without warranty. Author liable for nothing.`
9			`* DESCRIPTION:`
10			`* Plasma FTP server and FTP client and TFTP server and client`
11			`* and Telnet server.`
12			`--------------------------------------------------------------------/`
13	302	rhoads	`#define INCLUDE_FILESYS`
14	210	rhoads	`#ifdef WIN32`
15			`#include <stdio.h>`
16			`#include <stdlib.h>`
17			`#include <string.h>`
18			`#include <ctype.h>`
19			`#define _LIBC`
20			`#endif`
21			`#include "rtos.h"`
22			`#include "tcpip.h"`
23
24	215	rhoads
25			`//***************** FTP Server **********************`
26	210	rhoads	`typedef struct {`
27			`IPSocket *socket;`
28			`int ip, port, bytes, done, canReceive;`
29			`FILE *file;`
30			`} FtpdInfo;`
31
32			`static void FtpdSender(IPSocket *socket)`
33			`{`
34			`unsigned char buf[600];`
35			`int i, bytes, bytes2;`
36			`FtpdInfo info = (FtpdInfo)socket->userPtr;`
37
38			`if(info == NULL \|\| info->done)`
39			`return;`
40			`fseek(info->file, info->bytes, 0);`
41			`for(i = 0; i < 5; ++i)`
42			`{`
43			`bytes = fread(buf, 1, 512, info->file);`
44			`bytes2 = IPWrite(socket, buf, bytes);`
45			`info->bytes += bytes2;`
46			`if(bytes != bytes2)`
47			`return;`
48			`if(bytes < 512)`
49			`{`
50			`fclose(info->file);`
51			`IPClose(socket);`
52			`info->done = 1;`
53			`IPPrintf(info->socket, "226 Done\r\n");`
54			`return;`
55			`}`
56			`}`
57			`}`
58
59
60			`static void FtpdReceiver(IPSocket *socket)`
61			`{`
62			`unsigned char buf[600];`
63	225	rhoads	`int bytes, state = socket->state;`
64	210	rhoads	`FtpdInfo info = (FtpdInfo)socket->userPtr;`
65
66			`if(info == NULL \|\| info->done)`
67			`return;`
68	225	rhoads	`do`
69	210	rhoads	`{`
70	225	rhoads	`bytes = IPRead(socket, buf, sizeof(buf));`
71			`fwrite(buf, 1, bytes, info->file);`
72			`} while(bytes);`
73			`if(state > IP_TCP)`
74			`{`
75	210	rhoads	`fclose(info->file);`
76			`IPClose(socket);`
77			`info->done = 1;`
78			`IPPrintf(info->socket, "226 Done\r\n");`
79			`return;`
80			`}`
81			`}`
82
83
84	215	rhoads	`static void FtpdServer(IPSocket *socket)`
85	210	rhoads	`{`
86			`uint8 buf[600];`
87			`int bytes;`
88			`int ip0, ip1, ip2, ip3, port0, port1;`
89			`IPSocket *socketOut;`
90			`FtpdInfo info = (FtpdInfo)socket->userPtr;`
91
92			`if(socket == NULL)`
93			`return;`
94			`bytes = IPRead(socket, buf, sizeof(buf)-1);`
95			`buf[bytes] = 0;`
96			`//printf("(%s)\n", buf);`
97			`if(socket->userPtr == NULL)`
98			`{`
99			`info = (FtpdInfo*)malloc(sizeof(FtpdInfo));`
100			`if(info == NULL)`
101			`return;`
102			`memset(info, 0, sizeof(FtpdInfo));`
103			`socket->userPtr = info;`
104			`info->socket = socket;`
105	229	rhoads	`socket->timeoutReset = 60;`
106	210	rhoads	`IPPrintf(socket, "220 Connected to Plasma\r\n");`
107			`}`
108			`else if(strstr((char*)buf, "USER"))`
109			`{`
110			`if(strstr((char*)buf, "PlasmaSend"))`
111			`info->canReceive = 1;`
112			`IPPrintf(socket, "331 Password?\r\n");`
113			`}`
114			`else if(strstr((char*)buf, "PASS"))`
115			`{`
116			`IPPrintf(socket, "230 Logged in\r\n");`
117			`}`
118			`else if(strstr((char*)buf, "PORT"))`
119			`{`
120			`if(info == NULL)`
121			`return;`
122			`sscanf((char*)buf + 5, "%d,%d,%d,%d,%d,%d", &ip0, &ip1, &ip2, &ip3, &port0, &port1);`
123			`info->ip = (ip0 << 24) \| (ip1 << 16) \| (ip2 << 8) \| ip3;`
124			`info->port = (port0 << 8) \| port1;`
125			`//printf("ip=0x%x port=%d\n", info->ip, info->port);`
126			`IPPrintf(socket, "200 OK\r\n");`
127			`}`
128			`else if(strstr((char)buf, "RETR") \|\| strstr((char)buf, "STOR"))`
129			`{`
130			`char ptr = strstr((char)buf, "\r");`
131			`if(ptr)`
132			`*ptr = 0;`
133			`if(info == NULL)`
134			`return;`
135			`info->file = NULL;`
136			`info->bytes = 0;`
137			`info->done = 0;`
138			`if(strstr((char*)buf, "RETR"))`
139			`info->file = fopen((char*)buf + 5, "rb");`
140			`else if(info->canReceive)`
141			`info->file = fopen((char*)buf + 5, "wb");`
142			`if(info->file)`
143			`{`
144			`IPPrintf(socket, "150 File ready\r\n");`
145			`if(strstr((char*)buf, "RETR"))`
146			`socketOut = IPOpen(IP_MODE_TCP, info->ip, info->port, FtpdSender);`
147			`else`
148			`socketOut = IPOpen(IP_MODE_TCP, info->ip, info->port, FtpdReceiver);`
149			`if(socketOut)`
150			`socketOut->userPtr = info;`
151			`}`
152			`else`
153			`{`
154			`IPPrintf(socket, "500 Error\r\n");`
155			`}`
156			`}`
157			`else if(strstr((char*)buf, "QUIT"))`
158			`{`
159			`if(socket->userPtr)`
160			`free(socket->userPtr);`
161			`IPPrintf(socket, "221 Bye\r\n");`
162			`IPClose(socket);`
163			`}`
164			`else if(bytes)`
165			`{`
166			`IPPrintf(socket, "500 Error\r\n");`
167			`}`
168			`}`
169
170
171			`void FtpdInit(int UseFiles)`
172			`{`
173			`(void)UseFiles;`
174			`IPOpen(IP_MODE_TCP, 0, 21, FtpdServer);`
175			`}`
176
177
178			`//***************** FTP Client **********************`
179
180			`typedef struct {`
181			`uint32 ip, port;`
182			`char user[80], passwd[80], filename[80];`
183			`uint8 *buf;`
184			`int size, bytes, send, state;`
185			`} FtpInfo;`
186
187
188			`static void FtpCallbackTransfer(IPSocket *socket)`
189			`{`
190	225	rhoads	`int bytes, state = socket->state;`
191	210	rhoads	`FtpInfo info = (FtpInfo)socket->userPtr;`
192
193			`//printf("FtpCallbackTransfer\n");`
194			`if(info == NULL)`
195			`return;`
196			`bytes = info->size - info->bytes;`
197			`if(info->send == 0)`
198			`bytes = IPRead(socket, info->buf + info->bytes, bytes);`
199			`else`
200			`bytes = IPWrite(socket, info->buf + info->bytes, bytes);`
201			`info->bytes += bytes;`
202	225	rhoads	`if(info->bytes == info->size \|\| (bytes == 0 && state > IP_TCP))`
203	210	rhoads	`{`
204			`socket->userFunc(info->buf, info->bytes);`
205			`free(info);`
206			`socket->userPtr = NULL;`
207			`IPClose(socket);`
208			`}`
209			`}`
210
211
212			`static void FtpCallback(IPSocket *socket)`
213			`{`
214			`char buf[600];`
215			`FtpInfo info = (FtpInfo)socket->userPtr;`
216			`int bytes, value;`
217
218			`bytes = IPRead(socket, (uint8*)buf, sizeof(buf)-1);`
219			`if(bytes == 0)`
220			`return;`
221			`buf[bytes] = 0;`
222			`sscanf(buf, "%d", &value);`
223			`if(bytes > 2)`
224			`buf[bytes-2] = 0;`
225			`//printf("FtpCallback(%d:%s)\n", socket->userData, buf);`
226			`if(value / 100 != 2 && value / 100 != 3)`
227			`return;`
228			`buf[0] = 0;`
229			`switch(socket->userData) {`
230			`case 0:`
231			`sprintf(buf, "USER %s\r\n", info->user);`
232			`socket->userData = 1;`
233			`break;`
234			`case 1:`
235			`sprintf(buf, "PASS %s\r\n", info->passwd);`
236			`socket->userData = 2;`
237			`if(value == 331)`
238			`break; //possible fall-through`
239			`case 2:`
240			`sprintf(buf, "PORT %d,%d,%d,%d,%d,%d\r\n",`
241			`info->ip >> 24, (uint8)(info->ip >> 16),`
242			`(uint8)(info->ip >> 8), (uint8)info->ip,`
243			`(uint8)(info->port >> 8), (uint8)info->port);`
244			`socket->userData = 3;`
245			`break;`
246			`case 3:`
247			`if(info->send == 0)`
248			`sprintf(buf, "RETR %s\r\n", info->filename);`
249			`else`
250			`sprintf(buf, "STOR %s\r\n", info->filename);`
251			`socket->userData = 4;`
252			`break;`
253			`case 4:`
254			`sprintf(buf, "QUIT\r\n");`
255			`socket->userData = 9;`
256			`break;`
257			`}`
258			`IPWrite(socket, (uint8*)buf, strlen(buf));`
259			`IPWriteFlush(socket);`
260			`if(socket->userData == 9)`
261			`IPClose(socket);`
262			`}`
263
264
265			`IPSocket FtpTransfer(uint32 ip, char user, char *passwd,`
266			`char filename, uint8 buf, int size,`
267			`int send, void (callback)(uint8 data, int size))`
268			`{`
269			`IPSocket socket, socketTransfer;`
270			`FtpInfo *info;`
271			`uint8 *ptr;`
272			`info = (FtpInfo*)malloc(sizeof(FtpInfo));`
273			`if(info == NULL)`
274			`return NULL;`
275			`strncpy(info->user, user, 80);`
276			`strncpy(info->passwd, passwd, 80);`
277			`strncpy(info->filename, filename, 80);`
278			`info->buf = buf;`
279			`info->size = size;`
280			`info->send = send;`
281			`info->bytes = 0;`
282			`info->state = 0;`
283			`info->port = 2000;`
284			`socketTransfer = IPOpen(IP_MODE_TCP, 0, info->port, FtpCallbackTransfer);`
285			`socketTransfer->userPtr = info;`
286			`socketTransfer->userFunc = callback;`
287			`socket = IPOpen(IP_MODE_TCP, ip, 21, FtpCallback);`
288			`socket->userPtr = info;`
289			`socket->userFunc = callback;`
290			`ptr = socket->headerSend;`
291			`info->ip = IPAddressSelf();`
292			`return socket;`
293			`}`
294
295
296			`//***************** TFTP Server **********************`
297
298
299			`static void TftpdCallback(IPSocket *socket)`
300			`{`
301			`unsigned char buf[512+4];`
302			`int bytes, blockNum;`
303			`FILE file = (FILE)socket->userPtr;`
304			`bytes = IPRead(socket, buf, sizeof(buf));`
305			`//printf("TfptdCallback bytes=%d\n", bytes);`
306			`if(bytes < 4 \|\| buf[0])`
307			`return;`
308			`if(buf[1] == 1) //RRQ = Read Request`
309			`{`
310			`if(file)`
311			`fclose(file);`
312			`file = fopen((char*)buf+2, "rb");`
313			`socket->userPtr = file;`
314			`if(file == NULL)`
315			`{`
316			`buf[0] = 0;`
317			`buf[1] = 5; //ERROR`
318			`buf[2] = 0;`
319			`buf[3] = 0;`
320			`buf[4] = 'X'; //Error string`
321			`buf[5] = 0;`
322			`IPWrite(socket, buf, 6);`
323			`return;`
324			`}`
325			`}`
326			`if(buf[1] == 1 \|\| buf[1] == 4) //ACK`
327			`{`
328			`if(file == NULL)`
329			`return;`
330			`if(buf[1] == 1)`
331			`blockNum = 0;`
332			`else`
333			`blockNum = (buf[2] << 8) \| buf[3];`
334			`++blockNum;`
335			`buf[0] = 0;`
336			`buf[1] = 3; //DATA`
337			`buf[2] = (uint8)(blockNum >> 8);`
338			`buf[3] = (uint8)blockNum;`
339			`fseek(file, (blockNum-1)*512, 0);`
340			`bytes = fread(buf+4, 1, 512, file);`
341			`IPWrite(socket, buf, bytes+4);`
342			`}`
343			`}`
344
345
346			`void TftpdInit(void)`
347			`{`
348			`IPSocket *socket;`
349			`socket = IPOpen(IP_MODE_UDP, 0, 69, TftpdCallback);`
350			`}`
351
352
353			`//***************** TFTP Client **********************`
354
355
356			`static void TftpCallback(IPSocket *socket)`
357			`{`
358			`unsigned char buf[512+4];`
359			`int bytes, blockNum, length;`
360
361			`bytes = IPRead(socket, buf, sizeof(buf));`
362			`if(bytes < 4 \|\| buf[0])`
363			`return;`
364			`blockNum = (buf[2] << 8) \| buf[3];`
365			`length = blockNum * 512 - 512 + bytes - 4;`
366			`//printf("TftpCallback(%d,%d)\n", buf[1], blockNum);`
367			`if(length > (int)socket->userData)`
368			`{`
369			`bytes -= length - (int)socket->userData;`
370			`length = (int)socket->userData;`
371			`}`
372			`if(buf[1] == 3) //DATA`
373			`{`
374			`memcpy((uint8)socket->userPtr + blockNum 512 - 512, buf+4, bytes-4);`
375			`buf[1] = 4; //ACK`
376			`IPWrite(socket, buf, 4);`
377			`if(bytes-4 < 512)`
378			`{`
379			`socket->userFunc(socket->userPtr, length);`
380			`IPClose(socket);`
381			`}`
382			`}`
383			`}`
384
385
386			`IPSocket TftpTransfer(uint32 ip, char filename, uint8 *buffer, int size,`
387			`void (callback)(uint8 data, int bytes))`
388			`{`
389			`IPSocket *socket;`
390			`uint8 buf[512+4];`
391			`int bytes;`
392			`socket = IPOpen(IP_MODE_UDP, ip, 69, TftpCallback);`
393			`socket->userPtr = buffer;`
394			`socket->userData = size;`
395			`socket->userFunc = callback;`
396			`buf[0] = 0;`
397			`buf[1] = 1; //read`
398			`strcpy((char*)buf+2, filename);`
399			`bytes = strlen(filename);`
400			`strcpy((char*)buf+bytes+3, "octet");`
401			`IPWrite(socket, buf, bytes+9);`
402			`return socket;`
403			`}`
404
405
406			`//***************** Telnet Server **********************`
407
408	215	rhoads	`#define COMMAND_BUFFER_SIZE 80`
409			`#define COMMAND_BUFFER_COUNT 10`
410			`static char CommandHistory[400];`
411			`static char *CommandPtr[COMMAND_BUFFER_COUNT];`
412			`static int CommandIndex;`
413	210	rhoads	`static TelnetFunc_t *TelnetFuncList;`
414	229	rhoads	`static int BusyBox(IPSocket socket, char command);`
415	210	rhoads
416
417			`static void TelnetServer(IPSocket *socket)`
418			`{`
419	215	rhoads	`uint8 buf[COMMAND_BUFFER_SIZE+4];`
420			`char bufOut[COMMAND_BUFFER_SIZE+32];`
421	229	rhoads	`int bytes, i, j, length, rc;`
422	215	rhoads	`char ptr, command = socket->userPtr;`
423	210	rhoads	`bytes = IPRead(socket, buf, sizeof(buf)-1);`
424			`if(bytes == 0)`
425			`{`
426			`if(socket->userData)`
427			`return;`
428			`socket->userData = 1;`
429	215	rhoads	`socket->userPtr = command = (char*)malloc(COMMAND_BUFFER_SIZE);`
430			`if(command == NULL)`
431			`{`
432			`IPClose(socket);`
433			`return;`
434			`}`
435	229	rhoads	`socket->timeoutReset = 300;`
436	210	rhoads	`buf[0] = 255; //IAC`
437			`buf[1] = 251; //WILL`
438			`buf[2] = 3; //suppress go ahead`
439			`buf[3] = 255; //IAC`
440			`buf[4] = 251; //WILL`
441			`buf[5] = 1; //echo`
442	229	rhoads	`strcpy((char*)buf+6, "Welcome to Plasma.\r\n-> ");`
443	210	rhoads	`IPWrite(socket, buf, 6+23);`
444			`IPWriteFlush(socket);`
445			`command[0] = 0;`
446			`return;`
447			`}`
448	215	rhoads	`if(command == NULL)`
449			`return;`
450	210	rhoads	`buf[bytes] = 0;`
451	215	rhoads	`length = (int)strlen(command);`
452			`for(j = 0; j < bytes; ++j)`
453	210	rhoads	`{`
454	215	rhoads	`if(buf[j] == 255)`
455			`return;`
456			`if(buf[j] == 8 \|\| (buf[j] == 27 && buf[j+2] == 'D'))`
457	210	rhoads	`{`
458	215	rhoads	`if(buf[j] == 27)`
459			`j += 2;`
460			`if(length)`
461			`{`
462			`// Backspace`
463			`command[--length] = 0;`
464			`bufOut[0] = 8;`
465			`bufOut[1] = ' ';`
466			`bufOut[2] = 8;`
467			`IPWrite(socket, (uint8*)bufOut, 3);`
468			`}`
469	210	rhoads	`}`
470	215	rhoads	`else if(buf[j] == 27)`
471	210	rhoads	`{`
472	215	rhoads	`// Command History`
473			`if(buf[j+2] == 'A')`
474	210	rhoads	`{`
475	215	rhoads	`if(++CommandIndex > COMMAND_BUFFER_COUNT)`
476			`CommandIndex = COMMAND_BUFFER_COUNT;`
477	210	rhoads	`}`
478	215	rhoads	`else if(buf[j+2] == 'B')`
479			`{`
480			`if(--CommandIndex < 0)`
481			`CommandIndex = 0;`
482			`}`
483			`else`
484			`return;`
485			`bufOut[0] = 8;`
486			`bufOut[1] = ' ';`
487			`bufOut[2] = 8;`
488			`for(i = 0; i < length; ++i)`
489			`IPWrite(socket, (uint8*)bufOut, 3);`
490	315	rhoads	`command[0] = 0;`
491	215	rhoads	`if(CommandIndex && CommandPtr[CommandIndex-1])`
492	315	rhoads	`strncat(command, CommandPtr[CommandIndex-1], COMMAND_BUFFER_SIZE-1);`
493	215	rhoads	`length = (int)strlen(command);`
494			`IPWrite(socket, (uint8*)command, length);`
495			`j += 2;`
496	210	rhoads	`}`
497	215	rhoads	`else`
498	210	rhoads	`{`
499	229	rhoads	`if(length < COMMAND_BUFFER_SIZE-4 \|\| (length <`
500			`COMMAND_BUFFER_SIZE-2 && (buf[j] == '\r' \|\| buf[j] == '\n')))`

Browse

Tools

Subversion Repositories plasma

[/] [plasma/] [trunk/] [kernel/] [netutil.c] - Blame information for rev 315