Eu sempre uso GDB em uma sessão interativa ( gdb --args <program>)
Duas perguntas:
É possível configurar .gdbinitpara gerar automaticamente o arquivo de despejo de núcleo?
Em relação à primeira pergunta, se o programa travar, existe um comando de sessão do GDB para gerar manualmente o arquivo de despejo de memória?
Estou executando o ThreadSanitizer com sinalizadores de compilador -02 e g e sem gdb. Ele detecta a condição de corrida e imprime os rastreamentos de pilha, mas continua em execução. Tive a sorte de estar monitorando.
Existe uma maneira de forçar o ThreadSanitizer a travar ao detectar um problema?
O código abaixo usa listas Python para criar um gráfico Plotly.
Os carimbos de data e hora são milissegundos de época. Como formato o eixo x para data e hora legível?
Eu tentei fig.layout['xaxis_tickformat'] = '%HH-%MM-%SS', mas não funcionou.
import plotly.graph_objects as go
time_series = [1716693661000, 1716693662000, 1716693663000, 1716693664000]
prices = [20, 45, 32, 19]
fig = go.Figure()
fig.add_trace(go.Scatter(x=time_series, y=prices, yaxis='y'))
fig.update_layout(xaxis=dict(rangeslider=dict(visible=True),type="linear"))
fig.layout['xaxis_tickformat'] = '%Y-%m-%d'
fig.show()
Tenho três listas contendo dados para exibir via Plotly. A primeira coluna representa os carimbos de data e hora da época (com milissegundos) e a segunda e a terceira colunas são as séries a serem plotadas.
Estou tentando criar o dataframe do pandas corretamente, para passar para o Plotly.
Até agora eu tenho isso:
import pandas as pd
epoch=[1716591253000, 1716591254000, 1716591255000, 1716591256000]
series_1=[5,6,7,8]
series_2=[9,10,11,12]
df = pd.DataFrame(data=zip(epoch,series_1,series_2),columns=['Datetime','Series 1','Series 2'])
print(df)
Mas não tenho certeza de como dizer aos pandas que a primeira coluna é a coluna de data e hora e precisa ser o eixo x quando passada para Plotly.
Encontrei estes exemplos de séries temporais:
https://plotly.com/python/time-series/
mas infelizmente eles estão carregando dados pré-criados
Eu tenho três aulas. Cada classe tem seu próprio cabeçalho.
Gostaria que cada classe tivesse dois construtores adicionais para converter dos dois tipos restantes:
// A.h
A(const B& b){}
A(const C& c){}
// B.h
B(const A& a){}
B(const C& c){}
// C.h
C(const A& a){}
C(const B& b){}
No entanto, se eu incluir os outros dois cabeçalhos em cada cabeçalho, acabarei com uma dependência circular.
Qual é a melhor maneira de implementar isso?
Estou seguindo este exemplo de aplicação C de um sniffer de soquete bruto:
https://www.binarytides.com/packet-sniffer-code-c-linux/
Exceto que vinculei o soquete à minha interface depois de criar o soquete:
const std::string& iff = "wlp3s0";
int r = setsockopt(sock_raw, SOL_SOCKET, SO_BINDTODEVICE, iff.c_str(), iff.length());
if (r == -1)
{
std::abort();
}
Deixo então o aplicativo em execução:
sudo ./the_app
Abro o Wireshark e ouço a interface sem fio wlp3s0. Removi a interface Ethernet com fio da captura.
Em seguida, executo sudo dhclient -re sudo dhclientparo/inicio o DHCP e o Wireshark detecta 4 ou 5 pacotes DHCP, conforme esperado:
No entanto, o sniffer de soquete bruto C não mostra absolutamente nenhum pacote UDP recebido.
Se eu abrir um navegador da web, ele começará a mostrar pacotes TCP (o Wireshark relatou que os pacotes DHCP eram UDP).
O que está acontecendo? Estou usando Ubuntu 22.04
Exemplo mínimo:
#include<stdio.h> //For standard things
#include<stdlib.h> //malloc
#include<string.h> //memset
#include<netinet/ip_icmp.h> //Provides declarations for icmp header
#include<netinet/udp.h> //Provides declarations for udp header
#include<netinet/tcp.h> //Provides declarations for tcp header
#include<netinet/ip.h> //Provides declarations for ip header
#include<sys/socket.h>
#include<arpa/inet.h>
#include <unistd.h>
void ProcessPacket(unsigned char* , int);
int tcp=0,udp=0,icmp=0,others=0,igmp=0,total=0,i,j;
struct sockaddr_in source,dest;
int main()
{
unsigned char *buffer = (unsigned char *)malloc(65536); //Its Big!
printf("Starting...\n");
int sock_raw = socket(AF_INET , SOCK_RAW , IPPROTO_TCP);
if(sock_raw < 0)
{
std::abort();
}
int r = setsockopt(sock_raw, SOL_SOCKET, SO_BINDTODEVICE, "wlp3s0", strlen("wlp3s0"));
if (r == -1)
{
std::abort();
}
while(1)
{
int data_size = recv(sock_raw , buffer , 65536 , 0);
if(data_size <0 )
{
std::abort();
}
ProcessPacket(buffer , data_size);
}
::close(sock_raw);
return 0;
}
void ProcessPacket(unsigned char* buffer, int size)
{
//Get the IP Header part of this packet
struct iphdr *iph = (struct iphdr*)buffer;
++total;
switch (iph->protocol) //Check the Protocol and do accordingly...
{
case 1: //ICMP Protocol
++icmp;
//print_icmp_packet(buffer, size);
break;
case 2: //IGMP Protocol
++igmp;
break;
case 6: //TCP Protocol
++tcp;
//print_tcp_packet(buffer , size);
break;
case 17: //UDP Protocol
++udp;
//print_udp_packet(buffer , size);
break;
default: //Some Other Protocol like ARP etc.
++others;
break;
}
printf("TCP : %d UDP : %d ICMP : %d IGMP : %d Others : %d Total : %d\r",tcp,udp,icmp,igmp,others,total);
}
Gostaria de inserir e 'excluir' elementos em uma matriz de tamanho fixo. Após cada operação os elementos estão ordenados e contíguos (sem lacunas).
O primeiro elemento será inserido no meio.
Existe algum contêiner existente (incluindo Boost) que faça isso? Posso escrever um pouco da lógica, mas certamente este deve ser um requisito incomum.
Posso adicionar um pouco da lógica adicional/não-vanilla no topo.