// Conviertes de orden de bytes local a red
A = htons(A);
B = htons(B);
 
send(sock , &A , sizeof(A) , 0 );
send(sock , &B , sizeof(B) , 0 );
send(sock, &sign , sizeof(sign) , 0);
 
int32_t total;
read( sock , &total, sizeof(total));
 
// Conviertes de orden de bytes de red a local
total = ntohl(total);
std::cout <<  "El total es: " << total << "\n";

// Pesimos nombres de variables, pero por consistencia con tu codigo, los dejo asi
int16_t A, B;
char sign;
int32_t total;
read( new_socket , &A, sizeof(A) );
A = ntohs(A);
// ...y lo mismo para B y sign...

...
case '+':
	total = A + B;
break;
case '-':
	total = A - B;
break;
// etc.

total = htonl(total);
send(new_socket , &total, sizeof(total) , 0 );

// Como NO es una cadena, no necesita caracter nulo al final
char buffer[5];
/* Igual podriamos redondear a 8 chars, pues las potencias de 2 siempre son mucho mas agradables :) */ 

int restantes = TOTAL_A_ENVIAR;
while (restantes > 0) {
	int enviados = send(bytes_restantes_del_buffer);
	/* verificar el valor de enviados: si es igual a 0 o -1, algo salio mal. Lidiar con el error 	*/
	// En caso contrario
	restantes -= enviados;
}

while (getchar() != '\n');

void cargar(char***, int);

cargar(&array, N);

*array = (char**)malloc(lon * sizeof(char*));
...
(*array)[i] = (char*)malloc(tam * sizeof(char));

threadAddress[0] - module.BaseAddress

      if (!DbgHelpNative.SymFromAddr(hProc, (ulong)threadAddress[0], out displacement, ref symbolInfo))

                if (!DbgHelpNative.SymInitialize(hProc, null, true))
                {
                    throw new Win32Exception("SymInitialize failed");
                }

       [StructLayout(LayoutKind.Sequential)]
        public struct MODULEENTRY32
        {
            public uint dwSize;
            uint th32ModuleID;
            uint th32ProcessID;
            uint GlblcntUsage;
            uint ProccntUsage;
            public IntPtr modBaseAddr;
            public uint modBaseSize;
            IntPtr hModule;
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
            public string szModule;
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
            public string szExePath;
        }
 
        [DllImport("kernel32.dll", CharSet = CharSet.Ansi, SetLastError = true)]
        public static extern IntPtr CreateToolhelp32Snapshot(uint flags, uint processid);
        [DllImport("kernel32.dll", CharSet = CharSet.Ansi, SetLastError = true)]
        public static extern bool Module32First(IntPtr hSnapshot, ref MODULEENTRY32 lpme);
        [DllImport("kernel32.dll", CharSet = CharSet.Ansi, SetLastError = true)]
        public static extern bool Module32Next(IntPtr hSnapshot, ref MODULEENTRY32 lpme);

        private void get_process_thread_Click(object sender, EventArgs e)
        {
            Process proc = Process.GetProcessById(int.Parse(proc_txt.Text));
 
 
            // Los flags: TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32
            IntPtr hSnap = DbgHelpNative.CreateToolhelp32Snapshot(0x00000008 | 0x00000010, (uint)proc.Id);
 
            // INVALID_HANDLE_VALUE
            if ((long)hSnap == -1)
            {
                // Error
            }
 
            if (!DbgHelpNative.SymInitialize(proc.Handle, null, true))
            {
                throw new Win32Exception("SymInitialize failed");
            }
 
            DbgHelpNative.MODULEENTRY32 me = new DbgHelpNative.MODULEENTRY32();
 
            me.dwSize = (uint)Marshal.SizeOf(me);
 
            if (DbgHelpNative.Module32First(hSnap, ref me))
            {
                do
                {
                    if (0 == DbgHelpNative.SymLoadModule64(proc.Handle, IntPtr.Zero, me.szExePath, me.szModule, (ulong)me.modBaseAddr, (uint)me.modBaseSize))
                    {
                        /* Esta segunda verificacion es necesaria, ya que cuando SymLoadModule64
                         * devuelve 0, si TAMBIEN GetLastError es 0, simplemente significa
                         * que el modulo ya habia sido cargado*/
 
                        // En caso contrario, hay error
                        if (Marshal.GetLastWin32Error() != 0)
                        {
                            // Error: no se cargo el modulo
                        }
 
                    }
                } while (DbgHelpNative.Module32Next(hSnap, ref me));
            }
 
 
            ProcessThreadCollection procThread = proc.Threads;
            threadinfo_list.Items.Clear();
            int idx = 0;
            foreach (ProcessThread i in procThread)
            {
                threadinfo_list.Items.Add(i.Id.ToString());
                threadinfo_list.Items[idx].SubItems.Add(DbgHelp.GetThreadStartAddress(proc.Handle, (uint)i.Id));
                threadinfo_list.Items[idx].SubItems.Add(i.PriorityLevel.ToString());
                idx++;
            }
 
            DbgHelpNative.SymCleanup(proc.Handle);
            DbgHelpNative.CloseHandle(hSnap);
        }

HANDLE hProcess = GetCurrentProcess();
SymInitialize(hProcess, NULL, TRUE);
 
/* En C llamariamos a CreateToolhelp32Snapshot() y Module32First()/Module32Next() para obtener los modulos cargados.
En .NET creo que los obtienes directamente en Process.Modules */
For cada Modulo en proceso.Modules
	SymLoadModule64(hProcess, NULL, Modulo.FileName, Modulo.ModuleName, Modulo.BaseAddress, Modulo.ModuleMemorySize);
Next Modulo

/* En C, Thread32First()/Thread32Next(). En .NET, en la coleccion Threads */
IMAGEHLP_SYMBOL64 *pSym = NULL;
For cada thread en proceso.ProcessThreads
 

	HANDLE hThread = OpenThread(THREAD_ALL_ACCESS, false, thread.id);
	CONTEXT context;
	context.ContextFlags = CONTEXT_FULL;
 
	// Comparar el id, NO el handle
	if (thread.id == System.Threading.Thread.CurrentThread.ManagedThreadId)
              RtlCaptureContext(&context);
	else {
              SuspendThread(hThread);
              GetThreadContext(hThread, &context);
              ResumeThread(hThread);
	}

       size_t startAddress;
 
       NtQueryInformationThread(hThread, ThreadQuerySetWin32StartAddress, &startAddress, sizeof(startAddress), NULL);

       STACKFRAME64 sf64;
       sf64.AddrPC.Offset = context.Eip;
       sf64.AddrPC.Mode = AddrModeFlat;
       sf64.AddrFrame.Offset = context.Ebp;
       sf64.AddrFrame.Mode = AddrModeFlat;
       sf64.AddrStack.Offset = context.Esp;
       sf64.AddrStack.Mode = AddrModeFlat;
 
       StackWalk64(IMAGE_FILE_MACHINE_I386, hProcess, hThread, &sf64, &context, NULL, SymFunctionTableAccess64, SymGetModuleBase64, NULL);

       IMAGEHLP_MODULE64 module;
       memset(&module, 0, sizeof(module));
       module.SizeOfStruct = sizeof(module);
       SymGetModuleInfo64(hProcess, sf64.AddrPC.Offset, &module);
 

       IMAGEHLP_MODULE64 module;
       memset(&module, 0, sizeof(module));
       module.SizeOfStruct = sizeof(module);
       SymGetModuleInfo64(hProcess, startAddress, &module);
 

       if (!pSym) (IMAGEHLP_SYMBOL64*)malloc(sizeof(IMAGEHLP_SYMBOL64) + MAX_SYM_NAME * sizeof(TCHAR));
 
       memset(pSym, 0, sizeof(IMAGEHLP_SYMBOL64) + MAX_SYM_NAME);
       pSym->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64);
       pSym->MaxNameLength = MAX_SYM_NAME;
 
       SymGetSymFromAddr64(hProcess, startAddress, NULL, pSym);

	Console.WriteLine(module.ModuleName & "!" & pSym.Name & "+" (startAddress - pSym.Address).ToString("x"))
	CloseHandle(hThread);
Next thread
free(pSym);
 

miEjecutable!mainCRTStartup+0
ntdll!TpCallbackIndependent+140

[DllImport("ntdll.dll", CharSet = CharSet.Unicode, SetLastError = true)]
static extern int NtQueryInformationThread(IntPtr ThreadHandle, ThreadInfoClass ThreadInformationClass, IntPtr ThreadInformation, int ThreadInformationLength, IntPtr ReturnLength);