??? :3

chat_server.cpp

/* Лол, код из архива - файл датируется 2017 годом.
Написан был после недели изучения C++.
Реализует серверную часть чата на клиенте.
Код не полный, писался на скорую руку - так сказать proof of concept. 
О, и да - семафоры это круто :3 */
#include <iostream>
#include <string>
#include <stdio.h>
#include <cstring>
#include <stdlib.h>
#include <fstream>
#include <iomanip>

using namespace std;

//Vars

struct object_arguments {
	int arg_id;
	int arg_type;
	int arg_length;
	std::string arg;
	std::string type;
	struct object_arguments* next;
};

struct connection_node {
	int id; //Connection id
	string type; //Node type
	string flag; //Node flag
	string dec_message; //Decoded message
	string enc_message; //Encoded message
	int base_params[5]; //Base params array {message_length, sequence_id, command_id, obj_type, obj_id, arg_count}
	struct object_arguments* arguments;//Message arguments, decoded as nodes
	struct connection_node* next; //Next node vars
};
int cid = 1; //Connection starter id

typedef struct connection_node *Cnodes; //Connections nodes list, p.s. starter node
typedef struct object_arguments *Anodes; //Arguments defination

//Functions
	/**************************************Help_Functions*************************************/
		/*StringToChar_Function*/
		char * StringToChar(std::string in_string)
		{
			std::string str (in_string);
			char * cstr = new char [str.length()+1];
			std::strcpy (cstr, str.c_str());
			return cstr;
		}
		
		/*To10_Function*/
		int To10(std::string in_16)
		{
			char *input = StringToChar(in_16);
			char *next;
			long int value = strtol(input, &next, 16);
			return value;
		}
		
		/*To16_Function*/
		string To16(int in_10)
		{
			char c[100];
			int n=in_10;
			sprintf(c,"%X",n);
			return c;
		}
		
		/*Print_Array_Function*/
		void Print_Array(int array[5])
		{
			cout << "Array_Print:::" << endl << "---" << endl;
			cout << "message_length : " << array[0] << endl;
			cout << "sequence_id : " << array[1] << endl;
			cout << "command_id : " << array[2] << endl;
			cout << "obj_type : " << array[3] << endl;
			cout << "obj_id : " << array[4] << endl;
			cout << "arg_count : " << array[5] << endl;
		}
		
		/*FileGetContens_Function*/
		std::string FileGetContents(std::string file_path)
		{
			ifstream F;
			F.open(StringToChar(file_path), ios::in);
			std::string content;
			F>>content;
			return content;
		}
		
		/*FillString_Function*/
		std::string FillString(std::string base_string, std::string filler, int count, bool fill_from_left)
        {
            std::string result_string = base_string;
            int fill_count = count - base_string.length();
            if (fill_count <= 0)
            {
                //do nothing here
            }
            else
            {
                std::string new_result = base_string;
                if (fill_from_left == true)
                {
                    //fill it from left side
                    for (int i = 0; i < fill_count; i++)
                    {
                        new_result = filler + new_result;
                    }
                }
                else
                {
                    //fill it from right side
                    for (int i = 0; i < fill_count; i++, fill_count--)
                    {
                        new_result += filler;
                    }
                }
                result_string = new_result;
            }

            return result_string;
        }
	/**************************************Connections_Nodes_Functions*************************************/
		/*Init_Head_Node_Function*/
		Cnodes Init_Head_Node(void)
		{
			Cnodes head_node=NULL;
			head_node=new struct connection_node;
			head_node->id=0;
			head_node->type="head";
			head_node->flag="in_process";
			head_node->dec_message="";
			head_node->enc_message="";
			for(int i = 0; i<(sizeof(head_node->base_params)/sizeof(int));i++)
			{
				head_node->base_params[i]=0;
			}
			head_node->arguments=NULL;
			head_node->next=NULL;
			return head_node;
		}
		
		/*Init_Head_Anode_Function*/
		Anodes Init_Head_Anode(void)
		{
			Anodes head_anode = NULL;
			head_anode = new struct object_arguments;
			head_anode->arg_id = 0;
			head_anode->arg_type = 0;
			head_anode->arg_length = 0;
			head_anode->arg = "";
			head_anode->type = "head";
			head_anode->next = NULL;
			return head_anode;
		}
		
		/*Get_Last_Node_Function*/
		Cnodes Get_Last_Node(Cnodes &starter_node)
		{
			bool not_final = true;
			Cnodes current_node = starter_node;
			while( not_final )
			{
				if(current_node->next == NULL)
				{not_final = false;}
				else
				{current_node = current_node->next;}
			}
			return current_node;
		}
		
		/*Get_Last_Node_Function*/
		Anodes Get_Last_Anode(Anodes &starter_node)
		{
			bool not_final = true;
			Anodes current_node = starter_node;
			while( not_final )
			{
				if(current_node->next == NULL)
				{not_final = false;}
				else
				{current_node = current_node->next;}
			}
			return current_node;
		}

		/*Add_Node_Function*/
		Cnodes Add_Node(Cnodes &starter_node, Cnodes new_node)
		{
			Cnodes Last_Node = Get_Last_Node(starter_node);
			Last_Node->next = new_node;
			//(struct object_arguments *)malloc(sizeof(object_arguments))
			return Last_Node->next;
		}
		
		/*ReInit_Function*/
		void ReInit(Cnodes &starter_node)
		{
			Cnodes current_node = starter_node;
			while(current_node != NULL)
			{
				if(current_node->arguments == NULL)
				{
					current_node->arguments = new struct object_arguments;
					current_node->arguments = Init_Head_Anode();
				}
				current_node = current_node->next;
			}
		}
		
		/*Add_Anode_Function*/
		Anodes Add_Anode(Anodes &starter_node, Anodes new_node)
		{
			Anodes Last_Node = Get_Last_Anode(starter_node);
			Last_Node->next = new_node;
			return Last_Node->next;
		}
		
		/*Generate_New_Anode_Function*/
		Anodes Generate_New_Anode(int arg_id, int arg_type, int arg_length, std::string arg, std::string type, struct object_arguments* next)
		{
			Anodes new_anode = new struct object_arguments;
			new_anode->arg_id = arg_id;
			new_anode->arg_type = arg_type;
			new_anode->arg_length = arg_length;
			new_anode->arg = arg;
			new_anode->type = type;
			new_anode->next = next;
			return new_anode;
		}
		
		/*Generate_New_Node_Function*/
		Cnodes Generate_New_Node(int id, string type, string flag, string dec_message, string enc_message, int base_params[5], struct connection_node* next)
		{
			Cnodes new_node = new struct connection_node;
			new_node->id=id;
			new_node->type=type;
			new_node->flag=flag;
			new_node->dec_message=dec_message;
			new_node->enc_message=enc_message;
			for(int i = 0; i<(sizeof(new_node->base_params)/sizeof(int));i++)
			{
				new_node->base_params[i]=base_params[i];
			}
			new_node->next=next;
			return new_node;
		}

		/*Count_Nodes_Function*/
		int Count_Nodes(Cnodes starter_node)
		{
			int count = 0;
			bool not_final = true;
			Cnodes current_node = starter_node;
			while( not_final )
			{
				if(current_node->type != "head")
					{count++;}
				current_node = current_node->next;
				if(current_node == NULL)
				{not_final = false;}
			}
			return count;
		}
		
		/*Get_Node_By_Id_Function*/
		//Returns node->type=="null" if node is not founded
		Cnodes Get_Node_By_Id( Cnodes &starter_node, int node_id )
		{
			bool not_final = true;
			Cnodes current_node = starter_node;
			while( not_final )
			{
				if(current_node->id == node_id)
				{not_final = false;}
				else if(current_node->next == NULL)
				{not_final = false;int test[5] = {1,2,3,4,5};current_node = Generate_New_Node(-1,"null","null","","",test,NULL);}
				else
				{current_node = current_node->next;}
			}
			return current_node;
		}
		
		/*Remove_Node_Function*/
		void Remove_Node(Cnodes &starter_node, int node_id)
		{
			Cnodes prev_node = NULL;
			Cnodes current_node = starter_node->next;
			while( current_node != NULL )
			{
				if(current_node->id == node_id)
				{
					if( (prev_node == NULL) || (prev_node->type == "head") )
					{
					//cout << "first" <<current_node->id << endl;
						starter_node->next = current_node->next;
						delete current_node;
					}
					else if(current_node->next == NULL)
					{
					//cout << "second" <<current_node->id << endl;
						prev_node->next = NULL;
						delete current_node;
					}
					else
					{
					//cout << "third" <<current_node->id << endl;
						prev_node->next = prev_node->next->next;
						delete current_node;
					}
					break;
				}
				else
				{
					prev_node = current_node;
					current_node = current_node->next;
				}
			}
		}
		
		/*Print_Nodes_Function*/
		void Print_Nodes(Cnodes starter_node)
		{
			Cnodes current_node = starter_node;
			cout << "Cnodes : ";
			while( current_node != NULL )
			{
				cout << current_node->id <<",";
				current_node = current_node->next;
			}
			cout << endl;
		}
		
		/*Print_Anodes_Function*/
		void Print_Anodes(Anodes starter_node)
		{
			Anodes current_node = starter_node;
			cout << "Anodes : ";
			while( current_node != NULL )
			{
				cout << "{" << current_node->arg_id << ", " << current_node->arg_type << ", " << current_node->arg_length << "},";
				current_node = current_node->next;
			}
			cout << endl;
		}
		
		/*Clear_Flags_Function*/
		void Clear_Flags(Cnodes starter_node, Cnodes &starter_node_link, string frag)
		{
			Cnodes current_node = starter_node;
			while( current_node != NULL )
			{
				if(current_node->flag == frag)
				{Remove_Node(starter_node_link,current_node->id);}
				current_node = current_node->next;
			}
		}
		
		/*CheckIfObjectExists_Function*/
		bool CheckIfObjectExists(Cnodes starter_node, int node_id)
		{
			Cnodes current_node = starter_node;
			bool isset = false;
			while( current_node != NULL )
			{
				if(current_node->id == node_id)
				{isset = true;break;}
				current_node = current_node->next;
			}
			return isset;
		}
		
	/**************************************WBDS_Functions*************************************/
		/*DecodeMessageBaseParams_Function*/
		//Decoding WBDS message to base params, it's in number systems, they have view like 8 + 8 + 4 + 8 + 8 + 4 without plus(+)
		//First 8 bytes describes length of all message, minus 8 symbols(self)
		//Message looks e.x. : 0000002000000000000D00000003002B27640000
		void DecodeMessageBaseParams(std:: string dec_message, int * in_array)
		{
            char message_length[50];
            char sequence_id[50];
            char command_id[50];
            char obj_type[50];
            char obj_id[50];
            char arg_count[50];
			
			//decode 8 - 8,4,8,8,4
			sscanf(StringToChar(dec_message), "%8s%8s%4s%8s%8s%4s",&message_length,&sequence_id,&command_id,&obj_type,&obj_id,&arg_count);
			//printf("%d %d %d %d %d %d",message_length,sequence_id,command_id,obj_type,obj_id,arg_count);
			
			int array[6] = {To10(message_length),To10(sequence_id),To10(command_id),To10(obj_type),To10(obj_id),To10(arg_count)};
			
			in_array = array;
		}
		
		void TestFunc(int * array)
		{
			array[0] = 100500;
		}
		
		void UpdateMessageId(Cnodes &starter_node, int node_id, int message_new_id)
		{
			bool not_final = true;
			Cnodes current_node = starter_node;
			while( not_final )
			{
				if(current_node->id == node_id)
				{not_final = false;current_node->base_params[4]=message_new_id;}
				else if(current_node->next == NULL)
				{not_final = false;}
				else
				{current_node = current_node->next;}
			}
		}
		
		void UpdateMessageDec(Cnodes &starter_node, int node_id, std::string new_dec)
		{
			bool not_final = true;
			Cnodes current_node = starter_node;
			while( not_final )
			{
				if(current_node->id == node_id)
				{not_final = false;current_node->dec_message = new_dec;}
				else if(current_node->next == NULL)
				{not_final = false;}
				else
				{current_node = current_node->next;}
			}
		}
		
		bool IsMessageExists(Cnodes starter_node, int message_id)
		{
			bool not_final = true;
			bool result = false;
			Cnodes current_node = starter_node;
			while( not_final )
			{
				if(current_node->base_params[4] == message_id)
				{not_final = false;result=true;}
				else if(current_node->next == NULL)
				{not_final = false;}
				else
				{current_node = current_node->next;}
			}
			return result;
		}
		
		Cnodes GetMessageById(Cnodes starter_node, int base_params_id)
		{
			bool not_final = true;
			Cnodes current_node = starter_node;
			while( not_final )
			{
				if(current_node->base_params[4] == base_params_id)
				{not_final = false;}
				else if(current_node->next == NULL)
				{not_final = false;int test[5] = {1,2,3,4,5};current_node = Generate_New_Node(-1,"null","null","","",test,NULL);}
				else
				{current_node = current_node->next;}
			}
			return current_node;
		}
		
		/*GetChannelName_Function*/
		//Channel name by it's id
		std::string GetChannelName(int channel_id)
		{
		 switch(channel_id)
		 {
			case 1:
				return "OBJTYPE_MSG";
			break;
			case 2:
				return "OBJTYPE_AREA";
			break;
			case 3:
				return "OBJTYPE_USER";
			break;
			case 4:
				return "OBJTYPE_CLAN";
			break;
			case 5:
				return "OBJTYPE_TRADE";
			break;
			case 6:
				return "OBJTYPE_PARTY";
			break;
			case 7:
				return "OBJTYPE_RAID";
			break;
			case 10:
				return "OBJTYPE_AUX";
			break;
		 }
		}
		
		/*GetObjectArguments_Function*/
		//Decodes message arguments into nodes aka Array
		Anodes GetObjectArguments(Cnodes chain)
		{
			Anodes anode_starter = new struct object_arguments;
			anode_starter = Init_Head_Anode();
			int aknod = 0;
			
			int arguments_count = chain->base_params[5];
			std::string buffer = "";
			int start = 40;
			int arg_id, arg_type, arg_length;
			std::string arg = "";
			std::string message = chain->dec_message;
			
			while(arguments_count > 0)
			{
				//do it :)
                    //reading argument id
                    for (int i = start; i < (start+8); i++) { buffer += message[i]; }//8
                    arg_id = To10(buffer);
                    start += 8;
                    buffer = "";

                    //reading argument type
                    for (int i = start; i < (start + 4); i++) { buffer += message[i]; }//4
                    arg_type = To10(buffer);
                    start += 4;
                    buffer = "";

                    //reading argument length
                    for (int i = start; i < (start + 8); i++) { buffer += message[i]; }//8
                    arg_length = To10(buffer);
                    start += 8;
                    buffer = "";

                    //reading argument content
                    for (int i = start; i < (start + arg_length); i++) { buffer += message[i]; }//arg_length
                    arg = buffer;
                    start += arg_length;
                    buffer = "";

                    //goto
                    arguments_count -= 1;
					if( aknod == 0 )
					{
						anode_starter->next = Generate_New_Anode(arg_id,arg_type,arg_length,arg,"chain",NULL);
					}
					else
					{
						Anodes current_anode = anode_starter;
						for( int i = 0; i < aknod; i++ )
						{
							current_anode = current_anode->next;
						}
						current_anode->next = Generate_New_Anode(arg_id,arg_type,arg_length,arg,"chain",NULL);
					}
					aknod++;
			}
			return anode_starter;
		}
		
		/*MountString_Function*/
		std::string MountString( Cnodes cchain, Anodes achain )
		{
			//Encode base params
			std::string sequenceId = FillString( To16( cchain->base_params[1] ), "0", 8, true );
			std::string commandId = FillString( To16( cchain->base_params[2] ), "0", 4, true );
			std::string objType = FillString( To16( cchain->base_params[3] ), "0", 8, true );
			std::string objId = FillString( To16( cchain->base_params[4] ), "0", 8, true );
			std::string argCount = FillString( To16( cchain->base_params[5] ), "0", 4, true );
			
			//Encode arguments list
			std::string args_string = "";
			if( cchain->base_params[5] > 0 )
			{
				Anodes carg = achain->next;
				bool not_final = true;
				while(not_final)
				{
						args_string += FillString( To16( carg->arg_id ), "0", 8, true );
						args_string += FillString( To16( carg->arg_type ), "0", 4, true );
						args_string += FillString( To16( carg->arg_length ), "0", 8, true );
						args_string += carg->arg;
						if(carg->next == NULL)
							not_final = false;
						else
							carg = carg->next;
				}
			}
			
			//length
			std::string msg_resulted = sequenceId + commandId + objType + objId + argCount + args_string;
			std::string messageLength = FillString( To16( msg_resulted.length() ), "0", 8, true );
			
			//Implode all parts
			std::string result = messageLength + sequenceId + commandId + objType + objId + argCount + args_string;
			
			//Return result
			return result;
		}

Cnodes Node_Starter = new struct connection_node;
int main() {

	Node_Starter = Init_Head_Node();
	int test[5] = {1,2,3,4,5};
	Add_Node(Node_Starter,Generate_New_Node(cid++,"message","in_process","","",test,NULL));
	Add_Node(Node_Starter,Generate_New_Node(cid++,"message","in_process",FileGetContents("E:\\cpp_daemon\\test_message.txt"),"",test,NULL));

	Remove_Node(Node_Starter,1);
	Clear_Flags(Node_Starter,Node_Starter,"off_process");
	cout << "Last_Node_Type : " << Get_Last_Node(Node_Starter)->type << endl;
	cout << "Nodes Count : " << Count_Nodes(Node_Starter) << endl;
	int search_node = 4;
	Cnodes search_result = Get_Node_By_Id(Node_Starter,search_node);
	if(search_result->type == "null")
	{cout << "Node id " << search_node << " not found" << endl;}
	else
	{
		cout << "Node id " << search_node << " found, type is " << search_result->type << endl;
	}
	Print_Nodes(Node_Starter);
	
	cout << endl << "---" << endl;
	
	int arrayz[6] = {0,0,0,0,0,0};
	
	DecodeMessageBaseParams(Node_Starter->next->enc_message,arrayz);
	
	if(CheckIfObjectExists(Node_Starter,2))
		cout << "ISSET" << endl;
	else
		cout << "NOT ISSET" << endl;
	
	//UpdateMessageEnc(Node_Starter,Node_Starter->next->id,"zbeta");
	cout << Node_Starter->next->enc_message << endl;
	Print_Array(Node_Starter->next->base_params);
	
	cout << GetChannelName(3) << endl;
	
	cout << endl << "---" << endl;
	
	cout << FillString("test","0",5,false) << endl;
	
	//cout << MountString( Get_Node_By_Id(Node_Starter,2), GetObjectArguments( Get_Node_By_Id(Node_Starter,2) ) ) << endl;
	
	cout << To16(255) << endl;
	
	if(IsMessageExists(Node_Starter,4))
		cout << "Exists" << endl;
	else
		cout << "Not Exists" << endl;
		
	int tester = 100;
	
	char testers[10] = "";
	
	sprintf(testers,"%d",tester);
	
	cout << " ::: " << testers << endl;
	
	const int TEST_CONST = 0xFF;
	
	cout << TEST_CONST << endl;
	
	std::string ztest = "100500";
	
	int varz;
	
	varz = atoi(ztest.c_str());
	
	cout << ":::->" <<varz <<" / " <<ztest.size() <<endl;
	
	int arrayzt[1] = {-100};
	
	TestFunc(arrayzt);
	
	cout << arrayzt[0];
	
}

в 19 ​​вижуалке ругается что то

Говнокод потому что.

настоящий профессионал!... в сфере говнокодинга

настоящий профессионал!... в сфере говнокодинга

Согласен

лютый гавнокод, чел, удали себя

уже нашли откуда был спизжен код?

такой гавнокод мог написать только он и дударь, выбора немного

класный код

в 19 вижуалке ругается что то

Код компилился под Linux через GCC.

Сам файлик из архива - датируется 2017 годом.
Написан был после недели изучения C++.
Реализует серверную часть чата на клиенте.
Код не полный, писался на скорую руку - типа proof of concept.
О, и да - семафоры это круто :3

	/*MountString_Function*/
	std::string MountString( Cnodes cchain, Anodes achain )

спасибо за комментарии

Одобряю, хороший код. Хауди, сделаешь код-ревью моих проектов на С++?

Хауди Хо, разлогинься

Сам файлик из архива - датируется 2017 годом.
Написан был после недели изучения C++.
Реализует серверную часть чата на клиенте.
Код не полный, писался на скорую руку - типа proof of concept.
О, и да - семафоры это круто :3

ты за неделю не мог выучить хотя бы основы ООП? Ладно бы ты был новичком и с++ был бы твоим первый ЯП, но у тебя был большой опыт до этого чел.... За неделю ты мог бы выучить больше. И уж точно не гавнокодить так

😭😭😭

Ну тут и токсики. Каждый имеет право на не очень хороший код. Главное, чтобы он не вредил

позитивно

Посмотрите на мой говнокод у меня в профиле, поставьте звездочек, позязя :З

Ахахахаха, даже у меня не настолько говнокод

Проснувшись утром я почувствовал мимолетный, но уже довольно едкий запашок. Полусонный мозг подсказывал мне, что это запах экскрементов. Греша на кота я методично начал осматривать комнату в поисках источника запаха. Каковым же было мое удивление, когда я увидел коричневые разводы на своем мониторе. Пиксели буквально источали невыносимый смрад. Я протер монитор, а под толстым зловонным слоем оказался 100% ЛУЧШИЙ КОД ОТ ПРОФЕССИОНАЛА С++. Коту дал ментального пинка, а Хауди Хо - лучший ютубер ever.

Мне сегодня снилось, что я водитель автобуса программирования, почти все программисты были пассажирами, все выглядели как бомжи, грязные, в рваной одежде. Запомнил только Хауди, он был полуголым, в грязи, бегал по салону и визжал какую-то хуйню, я его ударил пару раз