Processos concorrentes [RESOLVIDO]

Pessoal, segue minha dúvida:
Estou fazendo um projeto e preciso fazer um complemento ao script que tenho. Consiste basicamente em executar um processo durante o período em que outro processo estiver sendo executado. Explicando melhor. Eu preciso fazer uma captura de dados da rede com o tshark (versão modo texto do wireshark), mas eu quero que o processo do tshark seja executado durante o tempo em que eu executo outro processo, que no caso, envia requisições http para uma lista de sites.
Explicando de outra forma, eu faço o seguinte:
# processo1 #tshark capturando dados
# processo2 #envio de requisições http

mas eu quero que o processo1 fique sendo executando enquando o processo2 esteja sendo executado. Então, quando o processo2 terminar, o processo1 termine também.

não sei se a explicação ficou clara. Quero que o processo1 rode durante todo o tempo em que o processo2 esteja rodando.
Putz, expliquei a mesma coisa um monte de vezes.
De qualquer forma, caso alguém não tenha conseguido entender, basta perguntar.

Desde já agradeço a ajuda de todos!!

O processo 1 vai subir manualmente?

Veja se entendi:
Quando vc iniciar o processo 1, deve subir o processo 2.
Assim que acabar o processo 1, deve ser finalizado o processo 2.

Quase...
o processo1 é executado manualmente
aí o processo2 deve ser executado e o processo1 deve parar quando o processo2 terminar.

Ótima solução.
Eu tinha pensado na mesma coisa sobre como parar o processo... pois não faço idéia de como fazer isso e o tshark salvar os pacotes de captura.
Antes eu tava parando o tshark com uma condição de tempo que o próprio tshark tem, então ele executava por 10 segundos, que era mais ou menos o tempo que o processo das requisições http demorava.
Mas fazendo uns testes, quando a rede tava sobrecarregada, vi que as requisições http demoravam cerca de 20 segundos. Além disso, eu faço as requisições com base num arquivo de texto que contém endereços de sites, isso significa que quanto mais endereços, mais tempo vai demorar. Por isso que busquei essa solução.
Vou testar aqui essa solução que você passou. Se esse método de matar o processo for interpretado pelo tshark do mesmo jeito que um ctrl+c for, não terei problema.

De uma forma diferente e um pouco mais simples:

#!/bin/bash

$1 & $2 &

sleep 3; check=0

while [ $check != 1 ]; do 

 check=`pidof -s $1 || echo $?`

 sleep 3

done

killall -9 $2

exit 0

 

é só executar:

$ ./script processo1 processo2

Mas atenção com a ordem dos processos, o processo 2 ficará executando somente enquanto o processo 1 estiver ativo, e não ao contrário.

Valeu rai3mb. Implementei o que você sugeriu e funcionou.
Ainda tem o problema de matar o processo. Mas isso não interferiu no resultado gerado pelo script, a princípio. Ainda assim, na execução, aparece que o processo foi "morto", mas a execução prossegue e os arquivos de saída são populados com os dados que quero.
Vou verificar se os dados que o script gera estão corretos.
De qualquer forma, muito obrigado pela ajuda.
Vou marcar o tópico como resolvido, mas ainda assim, se alguém souber como terminar um processo sem "matar" ele, sou todo ouvidos
=D

Infelizmente (ou felizmente) não conheço essas ferramenta que vc tá usando, assim seria mais fácil entender a problemática ;-)

Mas no fim de semana, descobrir uns comandos que podem ajudar, veja:

$ kill -STOP $PID
Para a execução do processo sem matá-lo, em fim, dar um stop .
$ kill -CONT $PID
continua um processo anteriormente parado
$ kill -KILL $PID
mata o processo

Então vc pode tentar usar o -STOP para parar a execução do processo que vc não quer matar, e depois pode matá-lo, ou continuar a execução dele.

"Use GNU/Linux e tenha o mundo a seu gosto ;-)"

Vou testar sim.
Vou explicar o meu problema pra ver se você entende.
Eu preciso de uma informação que o tshark faz de um tipo de pacote, então preciso capturar alguns pacotes para poder analisar eles.
Entretando, eu preciso que esses pacotes sejam do tipo que eu quero e de sites confiáveis, em relação a disponibilidade.
Para isso eu criei um código em c que faz requisições http nesses sites, semelhante ao que um browser faz. No caso, eu tenho uma lista de sites, em um arquivo de texto e o código em c faz as requisições para esses sites um por um.
Então, para capturar os dados resultantes dessas requisições, eu uso o tshark.
Se eu soubesse o tempo que todas as requisições http fossem demorar, bastava eu mandar o tshark capturar pacotes por aquele período de tempo. Por exemplo, caso as requisições demorassem 10 segundos, eu executaria o tshark e mandaria ele executar por 12 segundos e logo em seguida eu executaria as requisições http.

Uma outra forma de explicar isso seria assim: Imagine que eu fico durante um tempão capturando pacotes da rede, e em um certo momento, enquando estou capturando, eu faço as requisições http. Depois bastaria eu filtrar os pacotes que tivessem como origem ou destino esses sites. Porém, pra otimizar o tempo, fiz essa estrutura.
Assim, eu executo o tshark para capturar os dados
Depois eu executo as requisições http
Quando as requisições http acabarem, o tshark deve ser parado també, pois depois eu ainda vou fazer esse filtro de pacotes que são apenas desses sites, e por isso, os pacotes que eu capturar enquanto as requisições http não estiverem sendo executadas serão eliminadas pelo filtro.

Não sei se fui claro, mas acho que agora ficou mais claro

Obrigado pela ajuda
=D

Apenas complementando.
usar o stop, conforme o amigo rai3mb disse, resolveu o problema de o processo aparecer sendo "morto" na execução do script
Obrigado

Hummm ;-)

Então naquele script processo1 = tshark e processo2 = seu_codigo_c, ai quando o processo2 terminar o processo1 deveria ser matado, mas como vc disse o bom é que ele seja parado apenas.

Enfim, teste com o -STOP, ai analise se ficou como vc quer, depois pode optar por matá-lo -KILL ou continuar para monitorar outros tráfegos, -CONT.

Abraços