Sunteți pe pagina 1din 7

Ministerul Educaţiei, Culturii și Cercetării al Republicii Moldova

Universitatea Tehnică a Moldovei


Departamentul Ingineria Software și Automatică

RAPORT

Lucrare de laborator Nr.1

Disciplina: Programarea în rețea

Tema: Socket | HTTP | Multithreading

A efectuat: st.gr.TI-181,
Chirtoacă Maxim

A verificat : Buldumac Oleg

Chișinău 2021
Scopul:

1. Să se creeze o cerere(request) GET HTTP către web-serverul website-ului me.utm.md


utilizînd socket.

2. Cu ajutorul expresiilor regulate să se extragă toate imaginile din raspunsul primit din punctul
1.

3. Utilizînd Socket, HTTP și firele de execuții să se descarce toate imaginile găsite din puncul 2
într-un folder. Imaginile să se descarce utilizînd maximum 4 fire de execuție concomitent.

Codul sursă:

[CreateSocket.cs]

using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Security;
using System.Net.Sockets;
using System.Text;

namespace Lab1
{
public class CreateSocket
{
public string Server { get; set; }
public int Port { get; set; }
public CreateSocket(string server, int port)
{
Server = server;
Port = port;
}

protected Socket ConnectSocket()


{
Socket s = null;
IPHostEntry hostEntry = null;
hostEntry = Dns.GetHostEntry(Server);

foreach (IPAddress address in hostEntry.AddressList)


{
IPEndPoint ipe = new IPEndPoint(address, Port);
Socket tempSocket = new Socket(ipe.AddressFamily, SocketType.Stream,
ProtocolType.Tcp);
tempSocket.Connect(ipe);

if (tempSocket.Connected)
{
s = tempSocket;
break;
}
else
{
continue;
}
}
return s;
}

protected string ReadRespMessage(Socket socket, SslStream sslStream)


{
byte[] buffer = new byte[2048];
StringBuilder messageData = new StringBuilder();
int bytes = -1;
do
{
if (sslStream != null)
{
bytes = sslStream.Read(buffer, 0, buffer.Length);
}
else
{
bytes = socket.Receive(buffer, buffer.Length, 0);
}
Decoder decoder = Encoding.UTF8.GetDecoder();
char[] chars = new char[decoder.GetCharCount(buffer, 0, bytes)];
decoder.GetChars(buffer, 0, bytes, chars, 0);
messageData.Append(chars);
} while (bytes != 0);

return messageData.ToString();
}

public virtual string SendReceive(string path) { return "SendReceive Not


Defined"; }
}
}

[Http.cs]

using System;
using System.Collections.Generic;
using System.Net.Sockets;
using System.Text;

namespace Lab1
{
public class HTTP : CreateSocket
{
public HTTP(string server, int port) : base(server, port) { }

public override string SendReceive(string path)


{
Byte[] bytesSend = Encoding.ASCII.GetBytes(new Request(Server,
path).Headers);
string page = "";
using (Socket s = ConnectSocket())
{
if (s == null)
{
return ("Connection failed");
}

s.Send(bytesSend, bytesSend.Length, 0);

page = ReadRespMessage(s, null);

s.Close();
Console.WriteLine("Client closed");
}
return page;
}
}
}

[Request.cs]

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;

namespace Lab1
{
class Request
{
public string Headers { get; set; }

public Request(string server, string path)


{
if (path == null)
{
path = "/";
}

Headers =
"Get " + path + " HTTP/1.1\r\n" +
"Host: " + server + "\r\n" +
"Accept: */*\r\n" +
"Accept Encoding: gzip, deflate\r\n" +
"Accept Language: ru-Ru,ru;q=0.9, en-Us;q=0.8,en;q=0.7\r\n" +
"Connection: close\r\n\r\n";
}
}
}

[Urls.cs]

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;

namespace Lab1
{
public class Urls
{
private Object MatchLock = new object();
private int Index { get; set; }
private string[] Matches { get; set; }
public CreateSocket CurrentSocket { get; set; }
public Urls(CreateSocket socket, MatchCollection mathes)
{
CurrentSocket = socket;
Matches = mathes.Cast<Match>()
.Select(MatchSelect)
.ToArray();
Index = -1;
}

public string GetFileUrl()


{
if (Index + 1 >= Matches.Length)
{
Console.WriteLine("No more image");
return null;
}

lock (MatchLock)
{
if (Index + 1 < Matches.Length)
{
Index += 1;
}
return Matches.ElementAt(Index);
}
}

public void DownloadImage()


{
string fileUrl = null;
do
{
fileUrl = GetFileUrl();
if (fileUrl != null)
{
Console.WriteLine("Thread:{0}, file:{1}", Thread.CurrentThread.Name,
FileName(fileUrl));
using (WebClient client = new WebClient())
{
client.DownloadFile(new Uri(fileUrl), @"F:\LabPR\" +
FileName(fileUrl));
}
}
} while (fileUrl != null);
}

private string MatchSelect(Match m)


{
string baseUrl = "";
string value = m.Groups[1].Value;
if (value.Contains("http://"))
{
return value;
}
baseUrl = "http://";
baseUrl += CurrentSocket.Server;

if (value.IndexOf("/") == 0)
{
return baseUrl + value;
}

return baseUrl + '/' + value;


}

private string FileName(string url)


{
string substr = url.Substring(url.LastIndexOf('/') + 1);
return Regex.Replace(substr, @"(\?|\|/)", "_");
}

}
}

[Program.cs]

using System;
using System.Net;
using System.Net.Security;
using System.Net.Sockets;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;

namespace Lab1
{
class Program
{
static void Main(string[] args)
{
string host = "me.utm.md";
int port = 80;

int threadsNr = 4;
CreateSocket socket = GetSocketbyPort(host, port);

Urls urls = new Urls(socket, GetMatchCollection(socket.SendReceive(null)));

StartThreads(urls, threadsNr);

Console.ReadLine();
}

static CreateSocket GetSocketbyPort(string server, int port)


{
return new HTTP(server, port);
}

static MatchCollection GetMatchCollection(string html)


{
string pattern = @"<img.+?src=[""'](.+?(.jpg|.png|.gif|.jpeg))[""'].*?>";
Regex rgx = new Regex(pattern);

return rgx.Matches(html);
}

static void StartThreads(Urls urls, int threadsNr)


{
Thread[] threads = new Thread[threadsNr];
Thread.CurrentThread.Name = "main";
for (int i = 0; i < threadsNr; i++)
{
Thread t = new Thread(new ThreadStart(urls.DownloadImage));
t.Name = "T" + (i + 1).ToString();
threads[i] = t;
}
for (int i = 0; i < threadsNr; i++)
{
Console.WriteLine("Thread {0} Alive: {1}", threads[i].Name,
threads[i].IsAlive);
threads[i].Start();
Console.WriteLine("Thread {0} Alive: {1}", threads[i].Name,
threads[i].IsAlive);
}
}
}
}

Fig 1Resultatul executarii

Concluzii:

La lucrarea data a fost studiata posibilitatea de descarcare a unor fisiere de pe server utilizand
socket. Ca scop a fost descarcarea image fisierelor de pe site-ul me.utm.md.

S-ar putea să vă placă și