Programación de transferencia
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, que incluye:
// MSG_OPENFILE_ERROR : No se puede abrir el archivo.
// MSG_FILEALREADYEXIT_ERROR: El archivo a guardar ya existe.
Estructura TMSG_Error_Message: TMSG_Header público
{
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)
{
}
};
//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, que incluye:
// MSG_OPENFILE_ERROR : No se puede abrir el archivo.
// MSG_FILEALREADYEXIT_ERROR: El archivo a guardar ya existe.
Estructura TMSG_Error_Message: TMSG_Header público
{
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 procesar 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()
{
init socket();
ListenToClient();
cerrar socket();
Devuelve 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 ");
Return;
}
// Vincula el socket a la dirección local
sockaddr _ en sin
sin.sin _ familia = AF _ INET
sin . 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 entrada de socket 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 =::aceptar(s escuchar, (sockaddr *) amp; cliente addr amp; nAddrLen)))
{
}
mientras (true == 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, ampwsaData)!= 0)
{
printf("Error de inicio de socket dll\n");
{
p>
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);
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)
{
Caso nombre_archivo_mensaje://nombre de archivo
{
OpenFile(pMsgHeader, s client) ;
}
Pausa;
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);
p>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_FileLengthTMSGFileLength(g_lLength);
//Procesa el nombre de ruta completo del archivo y descompone 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 nombre tMsgFileName
strcpy(tMsgFileName.szFileName, SZ fname);
p>printf("Enviar nombre de archivo: s\n ", tmsgfilename . SZ nombre de archivo);
* enviar(s client, (char *)( amp; tMsgFileName), sizeof(CCS def). :: TMSG _ nombre de archivo), 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
Abrir archivo booleano ( CCS def::TMSG_header*pMsgHeader, cliente de socket)
{
CCS def::TMSG_filename* prequestfilename msg = (CCS def::TMSG_ Nombre de archivo *)pMsgHeader;
//Hacer algo procesamiento en el nombre de la ruta del archivo.
char *p1, * p2
for(p 1 = pRequestFilenameMsg- gt; szFileName, p2 = g_szNewFileName
'\0' != * p 1
p1, p2)
{
if ('\n '!= *p1)
{
* p2 = * p 1;
}
si ('\\' == *p2)
{
*( p2)= ' \ \ ';
}
}
* p2 = ' \ 0
LeerArchivo (s client);
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; iltg_lLengthi = nPacketBufferSize)
{
CCS def::TMSG_FILE tMsgFile;
tmsgfile . nstart = I;
if(I nPacketBufferSize 1 gt; g _ lLength)
{
tmsgfile . ;
}
Otro
{
tmsgfile . tfile .nsize = nPacketBufferSize
}
//printf("inicio = d, tamaño = d\n ", tMsgFile.tFile.nStart, tmsgfile . tfile . nsize
memcpy(tMsgFile. tFile.szBuff, g_pBuff); tMsgFile.tFile.nStart, tmsgfile.tfile.nsize);
* enviar(s cliente, (char *)(&tMsgFile), sizeof(CCS def::TMSG_file ),
);Dormir(0.5);
}
eliminar[]g _ pBuff
g _ pBuff = NULL
Regresar 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 g_sClient
//Inicializar la biblioteca de sockets
bool init socket();
//Cerrar la biblioteca de sockets
bool close socket();
p>
//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 write tofile(CCS def::TMSG_HEADER * pMsgHeader);
// Procesar mensajes enviados por el servidor.
bool ProcessMsg();
int main()
{
init socket();
ConectToServer();
cerrar socket();
Devolver 0;
}
//Inicializar la biblioteca de sockets
p>Booleano inicializar socket()
{
//Inicializar socket dll
WSADATA wsaData
WORD socketVersion = MAKEWORD(2, 2);
if (::WSAStartup(socketVersion, ampwsaData)!= 0)
{
printf("Error de inicio del dll del socket \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éctate 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);
}
/ /Transmitir 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_FilenametMsgRequestFileName
strcpy(tmsgrequestfilename.SZ nombre de archivo,SZ nombre de archivo);
if(SOCKET_ERROR = =::send (g_s client, (char *)(&tMsgRequestFileName), sizeof(CCS def::TMSG_FileName), 0))
{
printf("¡Enviar nombre de archivo 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- gt; cMsgID)
{
Caso MSG_OPENFILE_ERROR: //Se produjo un error al abrir el archivo.
{
error de archivo abierto (pMsgHeader);
}
Rotura;
Caso MSG_FILELENGTH: // La longitud del archivo.
{
if(0 = = g_length)
{
g_length =((CCS def::TMSG _Longitud del archivo*) pMsgHeader)- gt; lLongitud
printf("Longitud del archivo: d\n ", g _ l Longitud);
}
}
Interrupción;
Caso message_filename://nombredearchivo
{
Devolver AllocateMemoryForFile(pMsgHeader);
p>
}
Break;
Caso MSG_FILE: //Transfiere el archivo y sale de esta función después de escribirlo exitosamente.
{
if (WriteToFile(pMsgHeader))
{
Devuelve falso
}
}
Romper;
}
Devuelve verdadero
}
//No se puede abrir documento.
error bool openfile(CCS def::TMSG_HEADER * pMsgHeader)
{
if (NULL!= g_pBuff)
Devuelve verdadero
Aserción (NULL! = pMsgHeader);
printf("¡Archivo no encontrado! ¡Vuelva a ingresar!\n ");
// Re- ingrese 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)
{
Assertion(NULL!= pMsgHeader);
if ( NULL!= g_pBuff)
{
return true
}
CCS def::TMSG_filename* prequestfilename msg =(CCS def: :TMSG_filename*)pMsgHeader;
printf("Nombre de archivo: s\n ", nombre de archivo de solicitud msg-gt; nombre de archivo SZ);
/ /Establezca la ruta del archivo al directorio raíz de unidad c.
strcpy(g_szFileName, "c:\ \");
strcat(g_szFileName, nombre de archivo de solicitud msg- gt; nombre de archivo SZ
//Buscar); Compruebe si ya existe un archivo con el mismo nombre. Si hay un error, salga.
ARCHIVO * pFile
if (NULL!= (pFile = fopen(g_szFileName, " r "))
{
/ /El archivo ya existe. Debe ingresar un archivo nuevo.
printf("¡El archivo ya existe! \n"); READY_ERROR);
* enviar(g_s client, (char *)(&tMsgErrorMsg), sizeof(CCS def::TMSG_ERROR_MSG), 0);
fclose(pFile);
Devuelve falso
}
//Asigne un búfer para comenzar a recibir archivos. Si la asignación es exitosa, notifique al servidor. Envíe una solicitud para comenzar a transferir archivos.
g _ pBuff = nuevo carácter[g _ l longitud 1]
if (NULL!= g_pBuff)
{
memset(g_pBuff, ' \0 ', g_l longitud 1);
printf("¡Ahora listo para obtener los archivos!\n ", pRequestFilenameMsg- gt; SZ filename);
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("¡Error al asignar memoria para el archivo! \ n ");
Salir (-1);
}
Devuelve verdadero
}
//Escribir archivo
Escribir archivo booleano(CCS def:: TMSG_header*pMsgHeader)
{
Aserción(NULL!= pMsgHeader);
p>
CCS def::TMSG_File* pMsgFile = (CCS def ::TMSG_File*)pMsgHeader;
int nStart = pMsgFile-gt;tFile.nStart
int nSize = pMsgFile- gt;tFile.nSize
memcpy( g_pBuff nStart, pMsgFile- gt; tFile.szBuff, nSize);
if (0 == nStart)
{
printf("Guardar archivo en el búfer ...\ n ");
}
memcpy(g_pBuff nStart, pMsgFileg- gt;tFile.szBuff,nSize);
//printf( "start = d, size = d\n ",nStart,nSize);
//Si el archivo se ha guardado en el búfer, se escribe en el archivo.
if(nInicio nTamaño gt; = g _ lLongitud)
{
printf("Escribir en disco....\ n ");
p>
//Escribir archivo
FILE * pFile
pFile = fopen(g_szFileName, " w b "); (g_pBuff, sizeof( char), g_lLength, pFile);
eliminar[]g _ pBuff;
g _ pBuff = NULL
fclose(pFile) ;
// Guarde el archivo y envíe correctamente 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 correctamente!\n ", g _ SZ nombre de archivo);
Devuelve verdadero
}
Otro
{
Devuelve falso
}
}