/// <summary>
/// Funkcja dzialajaca na rzecz watku
/// </summary>
private void go()
{
try
{
while (true)
{
Thread.Sleep(2 * 60 * 1000); // odczekaj 2 min
GaduPacketHeader header = new GaduPacketHeader(); // przesylamy tylko naglowek
header.Type = GaduPacketConstans.GG_PING; // typu GG_PING
header.Length = 0; // po naglowku nic nie idzie, rozmiar 0
gaduSender.sendPacket(header); // wyslij pakiet
if (OnPing != null) // jezeli ktos podstawil jakas delegacje pod event
{
OnPing.BeginInvoke(null, null); // to ja wywolaj
}
}
}
catch (ThreadAbortException)
{ // nie zadreczajmy uzytkownika tym wyjatkiem, w 99% powodowany przez Thread.Abort();
}
catch (Exception e)
{ // jezeli cokolwiek poszlo nie tak
if (Gadu.GaduCriticalError() == false)
{
throw new GaduPingerException(e.Message);
}
}
}
/// <summary>
/// Przesyla cala liste na serwer
/// </summary>
public void sendAll()
{
try
{
GaduPacketHeader gaduPacketHeader;
GaduPacketUserListRequest gaduPacketUserlistRequest;
for (int i = 0; i < this.Count; i++)
{
gaduPacketHeader = new GaduPacketHeader();
gaduPacketUserlistRequest = new GaduPacketUserListRequest();
gaduPacketHeader.Type = GaduPacketConstans.GG_USERLIST_REQUEST;
gaduPacketUserlistRequest.Type = (i == 0 ? GaduPacketConstans.GG_USERLIST_PUT : GaduPacketConstans.GG_USERLIST_PUT_MORE);
gaduPacketUserlistRequest.Request = this[i].getUserListString();
gaduPacketHeader.Length = gaduPacketUserlistRequest.getSize();
gaduSender.sendPacket(gaduPacketHeader);
gaduSender.sendPacket(gaduPacketUserlistRequest);
}
}
catch (Exception exp)
{
throw new GaduUserListException(exp.Message);
}
}
/// <summary>
/// Usuwanie numerku w czasie pracy
/// </summary>
/// <param name="gaduPacketNotify">Numer do usuniecia reprezentowany przez pakiet GaduPacketNotify</param>
public void delNotify(GaduPacketNotify gaduPacketNotify)
{
GaduPacketHeader gaduPacketHeader = new GaduPacketHeader(); // naglowek
gaduPacketHeader.Type = GaduPacketConstans.GG_REMOVE_NOTIFY; // ustawiamy odpowiedni typ pakiety
gaduPacketHeader.Length = gaduPacketNotify.getSize(); // rozmiar pakiety
gaduSender.sendPacket(gaduPacketHeader); // wysylamy naglowek
gaduSender.sendPacket(gaduPacketNotify); // wysylamy pakiet
}
/// <summary>
/// Wysyla do servera zapytanie o uzytkownika
/// </summary>
/// <param name="gaduUser">Uzytkownik, ktorego chcemy znalezc</param>
public void Search(GaduUser gaduUser)
{
GaduPacketHeader gaduPacketHeader = new GaduPacketHeader();
GaduPacketPubDir50 gaduPacketPubDir50 = new GaduPacketPubDir50();
gaduPacketHeader.Type = GaduPacketConstans.GG_PUBDIR50_REQUEST;
gaduPacketPubDir50.Type = GaduPacketConstans.GG_PUBDIR50_SEARCH;
gaduPacketPubDir50.Seq = (int)DateTime.Now.Ticks;
gaduPacketPubDir50.Data = gaduUser.getPubDirString();
gaduPacketHeader.Length = gaduPacketPubDir50.getSize();
gaduSender.sendPacket(gaduPacketHeader);
gaduSender.sendPacket(gaduPacketPubDir50);
}
/// <summary>
/// Wysyla wszystkie pakiety na server
/// </summary>
public void sendNotify()
{
try
{
if (this.Count == 0) // jezeli nasza lista jest pusta
{
GaduPacketHeader header = new GaduPacketHeader();
header.Type = GaduPacketConstans.GG_LIST_EMPTY; // wysylamy tylko pakiet typu GG_LIST_EMPTY
header.Length = 0;
gaduSender.sendPacket(header);
}
else if (this.Count < 400) // jezeli lista ma mniej niz 400 wpisow, nie musimy jej dzielic
{
GaduPacketHeader header = new GaduPacketHeader();
header.Type = GaduPacketConstans.GG_NOTIFY_LAST; // pierwszy pakiet wysylamy jako ostatni
header.Length = this.Count * this[0].getSize(); // rozmiar = suma rozmiarow wszystkich pakietow, a wiec wysylamy
gaduSender.sendPacket(header); // wszystko jako jeden zlepek
for (int i = 0; i < this.Count; i++) // wysylamy kolejne pakiety
{
gaduSender.sendPacket(this[i]);
}
}
else // w tym trybie mamy wiecej niz 400 pakietow, musimy dzielic je po 400 wpisow
{
GaduPacketHeader header;
for (int i = 0; i < this.Count; i++)
{
if (i % 400 == 0 && i + 400 >= this.Count) // jezeli to juz ostatnie 400 pakietow
{
header = new GaduPacketHeader();
header.Type = GaduPacketConstans.GG_NOTIFY_LAST; // wyslij pakiety jako ostatni zlepek
header.Length = (this.Count - i) * this[0].getSize();
gaduSender.sendPacket(header);
}
else if (i % 400 == 0) // co 400 pakietow trzeba wyslac nowy naglowek
{
header = new GaduPacketHeader();
header.Type = GaduPacketConstans.GG_NOTIFY_FIRST;
header.Length = 400 * this[0].getSize();
gaduSender.sendPacket(header);
}
gaduSender.sendPacket(this[i]); // wysylamy dany pakiet
}
}
}
catch (Exception exp)
{
throw new GaduNotifierException(exp.Message);
}
}
/// <summary>
/// Logowanie do gg
/// </summary>
/// <param name="uin">Numer gg</param>
/// <param name="pass">Haslo</param>
public void login(int uin, String pass)
{
try
{
GaduPacketHeader header = new GaduPacketHeader(); // naglowek
GaduPacketLogin loginPacket = new GaduPacketLogin(); // pakiet logowania
header.Type = GaduPacketConstans.GG_LOGIN70; // bedziemy sie logowac
header.Length = loginPacket.getSize(); // dlugosc pakietu
loginPacket.Uin = uin; // nr. gg
loginPacket.Hash = BitConverter.GetBytes(getHash(pass, seed)); // szyfrujemy haslo, potem konwertujemy na tablice bajtow
gaduSender.sendPacket(header); // najpierw wpisujemy naglowek
gaduSender.sendPacket(loginPacket); // teraz wpiszemy wlasciwy pakiet
}
catch (Exception e)
{
throw new GaduLoginException(e.Message);
}
}
/// <summary>
/// Zmienia status uzytkownika gg
/// </summary>
/// <param name="statusid">Numer statusu nalezy pobrac z tad GaduPacketConstans.GG_STATUS_*</param>
/// <param name="descr">Opis, jezeli ustawilismy status, ktory nie jest typu *_DESCR, dajemy pusty string</param>
public void changeStatus(int statusid, string descr)
{
try
{
GaduPacketHeader header = new GaduPacketHeader(); // naglowek
GaduPacketStatus status = new GaduPacketStatus(); // pakiet zmieniajacy status
header.Type = GaduPacketConstans.GG_NEW_STATUS; // typ pakietu to zmiana status
status.Status = statusid; // przypisujemy status id
status.Description = descr; // narazie nie mamy zadnego opisu
header.Length = status.getSize(); // pobieramy rozmiar pakietu
gaduSender.sendPacket(header); // wysylamy naglowek
gaduSender.sendPacket(status); // wysylamy wlasciwiy pakiet
}
catch (Exception exp)
{
throw new GaduStatusException(exp.Message);
}
}
/// <summary>
/// Wysyla pakiet do servera, ktory sprawia ze ten przesle nam liste kontaktow
/// </summary>
public void getListFromServer()
{
try
{
GaduPacketHeader gaduPacketHeader = new GaduPacketHeader();
GaduPacketUserListRequest gaduPacketUserlistRequest = new GaduPacketUserListRequest();
gaduPacketHeader.Type = GaduPacketConstans.GG_USERLIST_REQUEST;
gaduPacketHeader.Length = 1;
gaduPacketUserlistRequest.Type = GaduPacketConstans.GG_USERLIST_GET;
gaduSender.sendPacket(gaduPacketHeader);
gaduSender.sendPacket(gaduPacketUserlistRequest);
}
catch (Exception exp)
{
throw new GaduUserListException(exp.Message);
}
}
/// <summary>
/// Wysyla wiadomosc pod dany numer
/// </summary>
/// <param name="uin">Numer odbiorcy</param>
/// <param name="msg">Wiadomosc</param>
public void sendMessage(int uin, string msg)
{
try
{
GaduPacketHeader header = new GaduPacketHeader(); // naglowek
GaduPacketMessage message = new GaduPacketMessage(); //wiadomosc
header.Type = GaduPacketConstans.GG_SEND_MSG; // bedziemy wysylac wiadomosc
message.Recepient = uin; // numer odbiorcy
message.Klasa = GaduPacketConstans.GG_CLASS_MSG; // klasa wiadomosci
message.Message = msg; // wiadomosc, string zostanie zamieniony na ciag bajtow
header.Length = message.getSize(); // wpisujemy wielkosc pakietu
gaduSender.sendPacket(header); // przesylamy najpierw naglowek
gaduSender.sendPacket(message); // potem przesylamy wiadomosc
}
catch (Exception exp)
{
throw new GaduMessageException(exp.Message);
}
}
/// <summary>
/// Zajmuje sie sprawdzaniem czy cos jest na gniezdzie, wczytywaniem naglowka
/// oraz calych pakietow
/// </summary>
private void go()
{
try
{
GaduPacketHeader header = new GaduPacketHeader(); // naglowek
while (true)
{
if (!tcpClient.Connected || tcpClient.GetStream().DataAvailable == false || work == false)
{ // jezeli na gniezdzie nie ma 8 pelnych bajtow lub gniazdo nie jest podlaczone to
Thread.Sleep(sleepTime); // czekamy na nowe pakiety
continue; // i przechodzimy do nastepnej iteracji
}
header.read(tcpClient.GetStream(), 8); // czytamy naglowek
if (OnPacket != null)
{
OnPacket.BeginInvoke(header, null, null);
}
switch (header.Type)
{
case GaduPacketConstans.GG_RECV_MSG: // ktos przyslal nam wiadomosc
GaduPacketRecieveMessage msg = new GaduPacketRecieveMessage();
msg.read(tcpClient.GetStream(), header.Length); // wczytujemy wiadomosc
if (OnRecieveMessage != null) // jezeli ktos podstawil swoja funkcje pod event
{
OnRecieveMessage.BeginInvoke(msg, null, null); // to ja wywolujemy podstawiajac jako argument pakiet z wiadomoscia
}
break;
case GaduPacketConstans.GG_SEND_MSG_ACK: // odebralismy pakiet potwierdzajacy wiadomosc
GaduPacketMessageAck ack = new GaduPacketMessageAck();
ack.read(tcpClient.GetStream(), header.Length); // wczytaj pakiet
if (OnRecieveMessageAck != null)
{
OnRecieveMessageAck.BeginInvoke(ack, null, null); // wywolaj event
}
break;
case GaduPacketConstans.GG_PONG: // otrzymalismy pakiet GG_PONG z servera
if (OnPong != null)
{
OnPong.BeginInvoke(null, null);
}
break;
case GaduPacketConstans.GG_LOGIN_OK: // otrzymalismy pakiet informujacy nas o tym ze logowanie sie powiodlo
if (header.Length == 1)
{
tcpClient.GetStream().ReadByte(); // jeden bajt, ktory nie zawsze musi sie pojawic, przeznaczenie nie poznane
}
if (OnLoginOK != null)
{
OnLoginOK.BeginInvoke(null, null); // wywolaj event
}
break;
case GaduPacketConstans.GG_NEED_EMAIL: // server chce abysmy uzupelnili e-mail w naszych danych
if (OnLoginNeedEmail != null)
{
OnLoginNeedEmail.BeginInvoke(null, null); // wywolaj event
}
break;
case GaduPacketConstans.GG_LOGIN_FAILED: // logowanie sie nie powiodlo
if (OnLoginFailed != null)
{
OnLoginFailed.BeginInvoke(null, null); // wywolaj event
}
break;
case GaduPacketConstans.GG_NOTIFY_REPLY77: // otrzymalismy pakiet mowiacy o tym ze ktos zmienil status
GaduPacketNotifyReplay77 gaduPacketNotifyReplay77;
while (header.Length > 0) // najprawdopodobnie bedzie to zlepek pakietow, a wiec bedziemy je wczytywac po kolei
{
gaduPacketNotifyReplay77 = new GaduPacketNotifyReplay77();
gaduPacketNotifyReplay77.read(tcpClient.GetStream(), header.Length);
header.Length -= gaduPacketNotifyReplay77.getSize();
if (OnGaduNotifyReplay != null)
{
OnGaduNotifyReplay.BeginInvoke(gaduPacketNotifyReplay77, null, null); // dla danego pakiety wywolaj event
}
}
break;
case GaduPacketConstans.GG_STATUS77: // ktos zmienil status na gg
GaduPacketStatus77 gaduPacketStatus77 = new GaduPacketStatus77();
gaduPacketStatus77.read(tcpClient.GetStream(), header.Length); // wczytujemy pakiet
if (OnGaduStatus != null)
{
OnGaduStatus.BeginInvoke(gaduPacketStatus77, null, null); // wywolujemny event
}
break;
case GaduPacketConstans.GG_USERLIST_REPLY:
GaduPacketUserListRequest gaduPacketUserlistReplay = new GaduPacketUserListRequest();
gaduPacketUserlistReplay.read(tcpClient.GetStream(), header.Length);
if (OnUserListReplay != null)
{
OnUserListReplay.BeginInvoke(gaduPacketUserlistReplay, null, null);
}
break;
case GaduPacketConstans.GG_PUBDIR50_REPLY:
GaduPacketPubDir50 gaduPacketPubDir50 = new GaduPacketPubDir50();
gaduPacketPubDir50.read(tcpClient.GetStream(), header.Length);
if (OnPubDirReplay != null)
{
OnPubDirReplay.BeginInvoke(gaduPacketPubDir50, null, null);
}
break;
case GaduPacketConstans.GG_DISCONNECTING:
if (OnGaduDisconnecting != null)
{
OnGaduDisconnecting.BeginInvoke(null, null);
}
break;
case GaduPacketConstans.GG_DISCONNECTING2:
if (OnGaduDisconnecting != null)
{
OnGaduDisconnecting.BeginInvoke(null, null);
}
break;
default: // jezeli otrzymalismy jakis pakiet, ktory jeszcze nie jest obslugiwany przez biblioteke
byte[] packet = new byte[header.Length];
for (int i = 0; i < header.Length; i++) // to wczytaj tylko pakiet z gniazda i nic z nim nie rob
{
packet[i] = (byte)tcpClient.GetStream().ReadByte();
}
if (OnUnhandledPacket != null)
{
OnUnhandledPacket.BeginInvoke(header, packet, null, null);
}
break;
}
}
}
catch (ThreadAbortException)
{ // nie zadreczajmy uzytkownika tym wyjatkiem, w 99% powodowany przez Thread.Abort()
}
catch (Exception e)
{
if (Gadu.GaduCriticalError() == false)
{
throw new GaduRecieverException(e.Message);
}
}
}
