Programación de transferencia de archivos
El código es el siguiente:
//Función: Código para usar SOCKET para transferir archivos.
/*server.h*/
#pragma comment(lib, "WS2_32")
#includes
#includes
//#includes
#includes
#ifndef COMMONDEF_H
#define COMMONDEF_H
# define max _ package_size 10240//Longitud máxima del paquete de datos, en sizeof(char).
#define MAXFILEDIRLENGTH 256 //La longitud máxima de la ruta del archivo de almacenamiento.
#Definir puerto 4096 //Número de puerto
# definir servidor _ IP " 127 . 0 . 0 . 1 " // La dirección IP del servidor.
//Definiciones de macros para varios mensajes
#define INVALID_MSG -1 //ID de mensaje no válido
#define MSG_FILENAME 1 //Nombre de archivo
#define MSG_FILELENGTH 2 //La longitud del archivo transferido
#define MSG_CLIENT_READY 3 //El cliente está listo para recibir el archivo.
#define message_file 4 //Transferir archivo
#define MSG_SENDFILESUCCESS 5 //Transferencia de archivo exitosa.
# define msg _ openfile _ error 10//El archivo no se puede abrir, tal vez porque la ruta del archivo es incorrecta y no se puede encontrar el archivo.
# define msg _ filealreadyexit _ error 11//El archivo a guardar ya existe.
Nivel CCSDef
{
Público:
#pragma pack(1) //Datos en estructura alineada de 1 byte, Guardar espacio.
//Encabezado del mensaje
Estructura TMSG_title
{
char cMsgID//ID del mensaje
TMSG_Header( char MsgID = INVALID_MSG)
:cMsgID(MsgID)
{
}
};
/ /El nombre del archivo solicitado para ser transferido
//El cliente envía el nombre de la ruta completa al servidor.
//Lo que el servidor devuelve al cliente es el nombre del archivo.
Estructura TMSG _filename: public TMSG _head
{
char SZ filename[256] //Matriz de caracteres para guardar el nombre del archivo.
Nombre del archivo TMSG ()
:Título TMSG (nombre del archivo del mensaje)
{
}
};
//Longitud del archivo de transferencia
Estructura TMSG _Longitud del archivo: public TMSG _Header
{
Longitud larga;
Longitud del archivo TMSG (longitud larga)
: encabezado TMSG (longitud del archivo de mensajes), longitud (longitud)
{
}
};
//El cliente está listo y el servidor necesita comenzar a transferir archivos.
struct TMSG_client_ready: public TMSG_header
{
TMSG_client_ready()
: encabezado TMSG (cliente de mensajes listo)
{
}
};
//Transferir archivo
Estructura TMSG_File:TMSG_Title público
{
Union // Union garantiza que el tamaño del paquete no sea mayor que MAX_PACKET_SIZE * sizeof(char).
{
char SZ buff[MAX _ PACKET _ TAMAÑO]
Estructura
{
int; nStart
int nSize
char SZ buff[MAX _ PACKET _ TAMAÑO-2 * sizeof(int)]
} tFile
};
Archivo TMSG()
:Título TMSG (archivo de mensaje)
{
}
};
//Transferencia de archivo exitosa.
Estructura TMSG_Enviar archivo exitosamente: public TMSG_header
{
TMSG_Enviar archivo exitosamente()
:Encabezado TMSG (Mensaje enviado archivo exitosamente)
{
}
};
//Enviar información de error, incluyendo:
// MSG_OPENFILE_ERROR : No se puede abrir el archivo.
// MSG_FILEALREADYEXIT_ERROR: El archivo a guardar ya existe.
Estructura TMSG_Error_Message:public TMSG_Header
{
TMSGErrorMessage
:TMSG_Header(cErrorMsg)
{
}
};
#Paquete Pragma()
};
#endif
/*server.h*/
#pragma comment(lib, "WS2_32")
#includes
#includes
//#includes
#includes
#ifndef COMMONDEF_H
#define COMMONDEF_H
# define max _ paquete _ tamaño 10240 / /La longitud máxima del paquete de datos, en tamaño de (char).
#define MAXFILEDIRLENGTH 256 //La longitud máxima de la ruta del archivo de almacenamiento.
#Definir puerto 4096 //Número de puerto
# definir servidor _ IP " 127 . 0 . 0 . 1 " // La dirección IP del servidor.
//Definiciones de macros para varios mensajes
#define INVALID_MSG -1 //ID de mensaje no válido
#define MSG_FILENAME 1 //Nombre de archivo
#define MSG_FILELENGTH 2 //La longitud del archivo transferido
#define MSG_CLIENT_READY 3 //El cliente está listo para recibir el archivo.
#define message_file 4 //Transferir archivo
#define MSG_SENDFILESUCCESS 5 //Transferencia de archivo exitosa.
# define msg _ openfile _ error 10//El archivo no se puede abrir, tal vez porque la ruta del archivo es incorrecta y no se puede encontrar el archivo.
# define msg _ filealreadyexit _ error 11//El archivo a guardar ya existe.
Nivel CCSDef
{
Público:
#pragma pack(1) //Datos en estructura alineada de 1 byte, Guardar espacio.
//Encabezado del mensaje
Estructura TMSG_title
{
char cMsgID//ID del mensaje
TMSG_Header( char MsgID = INVALID_MSG)
:cMsgID(MsgID)
{
}
};
/ /El nombre del archivo solicitado para ser transferido
//El cliente envía el nombre de la ruta completa al servidor.
//Lo que el servidor devuelve al cliente es el nombre del archivo.
Estructura TMSG _filename: public TMSG _head
{
char SZ filename[256] //Matriz de caracteres para guardar el nombre del archivo.
Nombre del archivo TMSG ()
:Título TMSG (nombre del archivo del mensaje)
{
}
};
//Transferir longitud del archivo
Estructura TMSG _Longitud del archivo: public TMSG _Header
{
Longitud larga;
Longitud del archivo TMSG (longitud larga)
: encabezado TMSG (longitud del archivo de mensajes), longitud (longitud)
{
}
};
//El cliente está listo y el servidor necesita comenzar a transferir archivos.
struct TMSG_client_ready: public TMSG_header
{
TMSG_client_ready()
: encabezado TMSG (cliente de mensajes listo)
{
}
};
//Transferir archivo
Estructura TMSG_File:TMSG_Title público
{
Union // Union garantiza que el tamaño del paquete no sea mayor que MAX_PACKET_SIZE * sizeof(char).
{
char SZ buff[MAX _ PACKET _ TAMAÑO]
Estructura
{
int; nStart
int nSize
char SZ buff[MAX _ PACKET _ TAMAÑO-2 * sizeof(int)]
} tFile
};
Archivo TMSG()
:Título TMSG (archivo de mensaje)
{
}
};
//Transferencia de archivo exitosa.
Estructura TMSG_Enviar archivo exitosamente: public TMSG_header
{
TMSG_Enviar archivo exitosamente()
:Encabezado TMSG (Mensaje enviado archivo exitosamente)
{
}
};
//Enviar información de error, incluyendo:
// MSG_OPENFILE_ERROR : No se puede abrir el archivo.
// MSG_FILEALREADYEXIT_ERROR: El archivo a guardar ya existe.
Estructura TMSG_Error_Message:public TMSG_Header
{
TMSGErrorMessage
:TMSG_Header(cErrorMsg)
{
}
};
#Paquete Pragma()
};
#endif
/*server.cpp*/
#Contiene "server.h"
char g _ szNewFileName[MAXFILEDIRLENGTH];
char g _ SZ buff [MAX _ PACKET _ TAMAÑO+1];
Longitud g _ lLongitud
char * g _ pBuff = NULL
//Inicializar la biblioteca de sockets
bool init socket();
//Cerrar la biblioteca de sockets
bool close socket();
//Analizar el mensaje y procesarlo en consecuencia.
bool ProcessMsg (cliente de socket);
//Escuchar mensajes del cliente
void ListenToClient();
/ /Abrir archivo
bool OpenFile(CCS def::TMSG_HEADER * pMsgHeader, cliente SOCKET);
//Transferir archivo
bool Enviar archivo (cliente socket);
//Leer el archivo en el buffer
bool ReadFile(SOCKET s client);
int main()
p>
{
iniciar socket();
ListenToClient();
cerrar socket();
Devolver 0;
}
void ListenToClient()
{
//Crear socket socket
SOCKET sListen = ::socket (AF_INET, SOCK_STREAM, IP proto _ TCP);
if (SOCKET_ERROR == sListen)
{
printf(" ¡Error al inicializar el socket! \n " );
Regresar;
}
// Vincular el socket a la dirección local
sockaddr _ en sin
sin.sin_familia = AF_INET
sin_PORT = htons(PORT);
sin_addrS_un. S_addr = INADDR_ANY
if (::bind(sListen, (LPSOCKADDR)&sin, sizeof(sockaddr_in))= = SOCKET_ERROR)
{
printf ("¡Error de enlace!\n ");
Regresar;
}
//Establecer el socket Ingrese al estado de escucha.
if (::listen(sListen, 10) == SOCKET_ERROR)
{
printf("¡Error de escucha!\n ");
Return;
}
printf("Escuchando al cliente...\ n ");
//Bucle para recibir el cliente solicitud de conexión.
sockaddr _ in ClientAddr
int nAddrLen = sizeof(sockaddr _ in);
Socket sClient
while(INVALID _ SOCKET = =(s cliente =::accept(s escucha, (sockaddr *)& dirección de cliente & nAddrLen)))
{
}
mientras (verdadero == ProcessMsg(sClient))
{
}
//Cerrar la conexión con el cliente.
* cerrar socket(s cliente);
* cerrar socket(s escucha);
}
socket de inicialización booleana ()
{
//Inicializar el dll del socket
WSADATA wsaData
WORD socketVersion = MAKEWORD(2, 2); >
if (::WSAStartup(socketVersion, &wsaData)!= 0)
{
printf("Error de dll de inicio del socket\n ");
Devuelve falso
}
Devuelve verdadero
}
bool CloseSocket()
{
//Liberar biblioteca winsock
* WSACleanup();
if (NULL!= g_pBuff)
{
eliminar[]g _ pBuff;
g _ pBuff = NULL
}
Devuelve verdadero
}
bool ProcessMsg(cliente de socket)
{
int nRecv = ::recv(sClient, g_szBuff, MAX_PACKET_SIZE + 1, 0
p>);
if(nRecv & gt; 0)
{
g _ SZ buff[nRecv]= ' \ 0 ';
}
//Comando de análisis
CCS def::TMSG _ HEADER * pMsgHeader =(CCS def::TMSG _ HEADER *)g _ szBuff;
Cambiar ( pMsgHeader- & gt;cMsgID)
{
case message_filename://nombredearchivo
{
OpenFile(pMsgHeader , s client <); /p>
}
Break;
Caso MSG_CLIENT_READY: //El cliente está listo para transferir archivos.
{
Enviar archivo(s cliente);
}
Pausa;
Caso MSG_SENDFILESUCCESS: / /Transferencia de archivos exitosa.
{
printf("¡El archivo se envió correctamente!\n ");
Devuelve falso
}
Break;
case msg_file yaexit_error://El archivo a guardar ya existe.
{
printf("¡El archivo a enviar ya existe! \ n "
Devuelve falso
}
Interrupción;
}
Devuelve verdadero
}
bool leer archivo (cliente de socket)
{
if (NULL!= g_pBuff)
{
Devuelve verdadero
}
//Abrir archivo
FILE * pFile
if(null = =(pfile = fopen(g_sznewfilename, "Rb))//No se puede abrir el archivo.
p>{
printf("Archivo no encontrado, solicite al cliente que ingrese el nombre del archivo nuevamente\n ");
CCS def::TMSG_Error_Message tMsgErrorMsg (message_open_file_error);
* enviar(s cliente, (char *)(&tMsgErrorMsg), sizeof(CCS def::TMSG_error_msg), 0);
Devuelve falso
}
//Enviar la longitud del archivo al cliente
fseek(pFile, 0, SEEK _ END. );
g _ lLength = ftell (pFile);
printf("Longitud del archivo = %d\n ", g _ l Longitud
CCS def::TMSG_file length Longitud del archivo TMSG (g_lLength);
* send(s client, (char *)(&tMsgFileLength), sizeof(CCS def::TMSG_file length), 0);
//Procesar el nombre de ruta completo de el archivo y descomponer el nombre del archivo.
char szDrive[_MAX_DRIVE], szDir[_MAX_DIR], szFname[_MAX_FNAME], szExt[_ MAX _ EXT]
_splitpath(g_szNewFileName, szDrive, szDir, szFname, szExt) ;
strcat(szFname, szExt);
CCS def::TMSG_File name tMsgFileName
strcpy(tMsgFileName.szFileName, SZ fname);
p>printf("Enviar nombre de archivo: %s\n ", tmsgfilename . SZ nombre de archivo
* enviar(s client, (char *)(& tMsgFileName), sizeof( CCS); def::TMSG_filename), 0);
//Asignar búfer para leer el contenido del archivo
g _ pBuff = new char[g _ l length+1 ];
if (NULL == g_pBuff)
{
Devuelve falso
}
fseek( pFile, 0, SEEK_SET) ;
fread(g_pBuff, sizeof(char), g_lLength, pFile);
g_pBuff[g_l length]= ' \ 0 ';
fclose(pFile );
Devuelve verdadero
}
//Abrir archivo
Archivo booleano abierto (CCS def::TMSG_header*pMsgHeader, socket client)
{
CCS def::TMSG_filename* prequestfilename msg = (CCS def: :TMSG _File name*)pMsgHeader;
//Hacer algún procesamiento en el nombre de la ruta del archivo.
char *p1, * p2
for(p 1 = pRequestFilenameMsg-> szFileName, p2 = g_szNewFileName
'\0' != * p 1 ;
++p1,++p2)
{
if ('\n '!= *p1)
{
* p2 = *p 1;
}
if ('\\' == *p2)
{
*(++ p2)= ' \ \ ';
}
}
* p2 = ' \ 0
ReadFile(s cliente);
Devuelve verdadero
}
//Transferir archivo
bool Enviar archivo (cliente de socket )
{
if (NULL == g_pBuff)
{
ReadFile(s cliente); >}
int nPacketBufferSize = MAX _ PACKET _ TAMAÑO-2 * sizeof(int); //El tamaño del búfer para almacenar archivos en cada paquete.
//Si la longitud del archivo es mayor que la longitud del búfer que cada paquete puede transmitir, se transmitirá en fragmentos.
for(int I = 0; i<g_lLengthi += nPacketBufferSize)
{
CCS def::TMSG_FILE tMsgFile;
tmsgfile . tfile .nstart = I;
if(I+nPacketBufferSize+1 & gt;g _ lLength)
{
tmsgfile . l longitud-I
}
Otro
{
tmsgfile .tfile . >}
//printf("inicio = %d, tamaño = %d\n ", tMsgFile.tFile.nStart, tmsgfile . tfile . nsize);
memcpy(tMsgFile); .tFile.szBuff, g_pBuff + tMsgFile.tFile.nStart, tmsgfile . tfile .
* enviar(s cliente, (char *)(& tMsgFile), sizeof(CCS def::TMSG_file) , 0);
dormir(0.5);
}
eliminar[]g_pBuff;
p>
g _ pBuff = NULL
Devuelve verdadero
}
/*client.h es lo mismo que server.h*/
/* client.cpp*/
#Contiene "client.h"
long g _ l length = 0
char * g _ pBuff = NULL
char g_SZ nombre de archivo[MAXFILEDIRLENGTH];
char g_SZ buff[MAX_PACKET_SIZE+1];
Socket Word g_sClient
//Inicializar el socket biblioteca
bool init socket();
//Cerrar la biblioteca de sockets
bool close socket();
//Enviar la ruta del archivo ingresada por el usuario al servidor.
bool SendFileNameToServer();
//Conéctate al servidor.
bool ConectToServer();
//El archivo no se puede abrir.
bool openfile error(CCS def::TMSG _ HEADER * pMsgHeader);
//Asignar espacio para escribir archivos
bool AllocateMemoryForFile(CCS def: : TMSG _ HEADER * pMsgHeader);
//Escribir archivo
bool escribir en archivo(CCS def::TMSG _ HEADER * pMsgHeader);
// Proceso mensajes enviados por el servidor.
bool ProcessMsg();
int main()
{
init socket();
ConectToServer();
cerrar socket();
Devolver 0;
}
//Inicializar la biblioteca de sockets
p>Boolean InitSocket()
{
//Inicializar el dll del socket
WSADATA wsaData
WORD socketVersion = MAKEWORD(2, 2);
if (::WSAStartup(socketVersion, & ampwsaData)!= 0)
{
printf("Iniciar socket dll error\n ");
Salir (-1);
}
Devolver verdadero
}
//Cerrar la biblioteca de sockets
bool CloseSocket()
{
//Cerrar el socket
* close socket(g_s client);
//Liberar biblioteca winsock
* WSACleanup();
Devuelve verdadero
}
//Conéctese al servidor para transferir archivos.
Servidor de conexión booleana()
{
//Inicializar socket socket
if(SOCKET _ ERROR = = (g_s client = ::SOCKET(AF_INET, SOCK_STREAM, IPPROTO_TCP)))
{
printf("¡Error al inicializar el socket!\n ");
Salir(-1 );
}
sockaddr _ in servAddr
servAddr.sin_family = AF_INET
serv addr . (PUERTO);
servAddr.sin_addr. Sol. s_addr =::inet_addr(SERVER_IP);
if(INVALID_SOCKET = =(::connect(g_s client, (sockaddr *)&servAddr, sizeof( sockaddr_in))))
{
printf("¡Error al conectar con el servidor!\n ");
Salir (-1);
}
//Transmite la ruta del archivo de entrada al servidor.
SendFileNameToServer();
//Recibir información del servidor hasta que el archivo se guarde correctamente.
mientras (true == ProcessMsg())
{
}
Devuelve verdadero
}
//Envía la ruta del archivo ingresada por el usuario al servidor.
bool SendFileNameToServer()
{
char SZ nombre de archivo[MAXFILEDIRLENGTH];
printf("Directorio de archivos de entrada:");
fgets(szFileName, MAXFILEDIRLENGTH, stdin);
//Envía la ruta del archivo al servidor.
CCSDef::TMSG _Nombre de archivo tMsgRequestFileName
strcpy(tmsgrequestfilename . Nombre de archivo SZ, nombre de archivo SZ
if(SOCKET _ ERROR = =::send (); g_s client, (char *)(&tMsgRequestFileName), sizeof(CCS def::TMSG_filename), 0))
{
printf(" ¡Nombre de archivo de envío incorrecto! \n ");
Salir (-1);
}
Devolver verdadero
}
// Procesar mensajes enviados por el servidor.
bool ProcessMsg()
{
CCS def::TMSG _ HEADER * pMsgHeader;
int nRecv = ::recv( g_sClient, g_szBuff, MAX_PACKET_SIZE + 1, 0);
pMsgHeader = (CCS def::TMSG_HEADER *)g_szBuff;
Cambiar (pMsgHeader-> cMsgID)
{
Caso MSG_OPENFILE_ERROR: //Ocurrió un error al abrir el archivo.
{
error de archivo abierto (pMsgHeader);
}
Rotura;
Caso MSG_FILELENGTH: // La longitud del archivo.
{
if(0 = = g _ longitud)
{
g _ longitud =((CCS def::TMSG _Longitud del archivo*)pMsgHeader)-& gt;lLongitud
printf("Longitud del archivo: %d\n ",g _ l Longitud);
}
}
Romper;
Caso message_filename://nombredearchivo
{
Devolver AllocateMemoryForFile(pMsgHeader
<); p>}Break;
Case MSG_FILE: //Transfiere el archivo y sale de esta función después de escribirlo correctamente.
{
if (WriteToFile(pMsgHeader))
{
Devuelve falso
}
}
Romper;
}
Devuelve verdadero
}
//No se puede abrir documento.
error bool de archivo abierto(CCS def::TMSG _ HEADER * pMsgHeader)
{
if (NULL!= g_pBuff)
Devuelve verdadero
Aserción (NULL! = pMsgHeader);
printf("¡Archivo no encontrado! ¡Vuelva a ingresar!\n ");
// Vuelva a ingresar el nombre del archivo.
SendFileNameToServer();
Devuelve verdadero
}
//Comprueba si el archivo a guardar ya existe y asigna un búfer Guarde el archivo.
bool AllocateMemoryForFile(CCS def::TMSG _ HEADER * pMsgHeader)
{
Aserción (NULL!= pMsgHeader);
if (NULL!= g_pBuff)
{
return true
}
CCS def::TMSG _filename* prequestfilename msg =( CCS def::TMSG _filename*)pMsgHeader;
printf("Filename:%s\n ", solicitar nombre de archivo msg-& gt;SZ filename);
//Establecer el ruta del archivo al directorio raíz de la unidad c.
strcpy(g_szFileName, " c:\ \ ");
strcat(g_szFileName, solicitar nombre de archivo msg-& gt; nombre de archivo SZ); Compruebe si ya existe un archivo con el mismo nombre y salga si hay un error.
ARCHIVO * pFile
if (NULL!= (pFile = fopen(g_szFileName, " r "))
{
/ /El archivo ya existe. Debe ingresar un archivo nuevo.
printf("¡El archivo ya existe! \n "); );
* send(g_s client, (char *)(&tMsgErrorMsg), sizeof(CCS def::TMSG_error_MSG),
fclose(pFile);<); /p>
Devuelve falso
}
//Asigna el búfer para comenzar a recibir el archivo. Si la asignación es exitosa, envía El servidor envía una solicitud para comenzar a transferir el archivo. archivo.
g _ pBuff = nuevo carácter[g _ l longitud+1]
if (NULL!= g_pBuff)
{
memset(g_pBuff, ' \0 ', g_l length+1);
printf("¡Ahora listo para obtener el archivo %s!\n ", pRequestFilenameMsg-& gt; SZ filename < /p); >
CCS def::TMSG_client_readytMsgClientReady
if(SOCKET_ERROR = =::send(g_s client, (char *)(&tMsgClientReady) , sizeof(CCS def::TMSG_client_ready), 0))
{
printf("¡Error de envío!\n ");
Salir(-1);
}
}
Otros
{
printf("¡Es un error de asignación de archivos! \n "); -1);
}
Devuelve verdadero
}
//Escribir archivo
Escribir archivo booleano (CCS def::TMSG _header*pMsgHeader)
{
Aserción (NULL!= pMsgHeader);
CCS def::TMSG_file* pMsgFile = (CCS def::TMSG_file*)pMsgHeader;
int nStart = pMsgFile-& gt;tFile.nStart
int nSize = pMsgFile->tFile.nSize
memcpy(g_pBuff + nStart, pMsgFile->tFile.szBuff,nSize);
if (0 == nStart)
{
printf("Guardar archivo al buffer...\ n ");
}
memcpy(g_pBuff + nStart, pMsgFile-& gt;tFile.szBuff, nSize);
//printf("start = %d, size = %d\n ",nStart,nSize );
//Si el archivo se ha guardado en el búfer, escríbalo en el archivo.
if(nInicio+nTamaño & gt; = g _ lLongitud)
{
printf("Escribir en disco....\ n ");
//Escribir archivo
FILE * pFile
pFile = fopen(g_szFileName, " w+b ");
fwrite( g_pBuff, sizeof(char), g_lLength, pFile);
delete[]g _ pBuff
g _ pBuff = NULL
fclose(pFile);
//Guarde el archivo y envíe con éxito un mensaje al servidor para salir del servidor.
CCS def::TMSG _Enviar archivo exitosamente tMsgSendFileSuccess
while(SOCKET _ ERROR = =::send(g_s client, (char *)(& tMsgSendFileSuccess) , sizeof(CCS def ::TMSG _ SENDFILESUCCESS), 0))
{
}
printf("¡Guarde el archivo %s correctamente!\n ", nombre de archivo g_SZ);
Devuelve verdadero
}
Otro
{
Devuelve falso
}
}