How can i create a TCP stream using Rust?

this is my first question and i hope you can help me.

Im trying to start a TCP stream to send HTTP messages using the Pnet library. The problem is when i try to send SYN packets but i dont receive any answer and i dont know whats the problem. I thought i was creating broken packets but i copy a SYN packet from a "telnet" operation and i get the same result.

I've tried so many ways and i still cant find a solution. Can anyone help me please?

extern crate pnet;
extern crate std;


use core::panic;
use std::io::Error;
use pnet::packet::ipv4::*;
use pnet::packet::ip::IpNextHeaderProtocol;
use pnet::packet::ip::IpNextHeaderProtocols;
use pnet::packet::ipv4::MutableIpv4Packet;
use pnet::packet::*;
use std::net::Ipv4Addr;
use pnet::transport::TransportChannelType::*;
use pnet::transport::TransportProtocol::*;
use pnet::transport::{transport_channel, ipv4_packet_iter};

use pnet::packet::*;
use pnet::packet::tcp::*;
use pnet::packet::tcp::MutableTcpPacket;
use pnet::packet::tcp::TcpOptionNumber;



pub fn create_ipv4_packet<'a>(buffer_ip: &'a mut [u8],ipv4Pac : pnet::packet::ipv4::Ipv4) -> MutableIpv4Packet {

    let mut ipv4_packet = MutableIpv4Packet::new(buffer_ip).unwrap();
    let ipv4_aux = ipv4Pac;

    ipv4_packet.populate(&ipv4_aux);    
    let mut num = 0;
    let mut inmutable = ipv4_packet.to_immutable();
    
    let checks = pnet::packet::ipv4::checksum(&inmutable); 
    num = checks;
    ipv4_packet.set_checksum(checks);
    

    return ipv4_packet;
}

pub fn sendSYN( sourceP : u16, destPort : u16 , ipPacket : MutableIpv4Packet){
        //TCP SYN Packet, obtain with telnet
        let mut tmp: [u8; 40] = [234, 28,0,80,84, 233,15,246,
         0,0,0,0,160,2,250,240,33,122,0,0,2,4,5,180,4,2,8,10,247,
         143,213,137,0,0,0,0,1,3,3,7];

        let tcpPackAux =  MutableTcpPacket::new( &mut tmp);
        let mut tcpPackOpt = tcpPackAux.unwrap();
 
        tcpPackOpt.set_source(sourceP);
        tcpPackOpt.set_destination(destPort);

        let packetTCP = tcpPackOpt.packet();
        let paqueteVecTCP = packetTCP.to_vec();

        let ipPacketCopy = ipPacket;

        let ipv4_TCPPayload = 
        pnet::packet::ipv4::Ipv4{version: ipPacketCopy.get_version(),
            header_length: ipPacketCopy.get_header_length(),
            dscp: ipPacketCopy.get_dscp(),
            ecn: ipPacketCopy.get_ecn(),
            total_length: ipPacketCopy.get_total_length(),
            identification: ipPacketCopy.get_identification(),
            flags: ipPacketCopy.get_flags(),
            fragment_offset: ipPacketCopy.get_fragment_offset(),
            ttl: ipPacketCopy.get_ttl(),
            next_level_protocol: ipPacketCopy.get_next_level_protocol(),
            checksum: ipPacketCopy.get_checksum(),
            source: ipPacketCopy.get_source(),
            destination: ipPacketCopy.get_destination(),
            options: ipPacketCopy.get_options(),
            payload: paqueteVecTCP.clone(), //Payload TCP 
        }; 
        let mut protocol = pnet::transport::TransportChannelType::Layer3(IpNextHeaderProtocols::Tcp);
        

        let (mut px, mut rx) = match transport_channel(4096, protocol) { // Tamaño de 4096 bytes
            Ok((tx, rx)) => (tx, rx),
            Err(e) =>  panic!(),
        };

        let mut int_slice = [0u8; 60]; //60 = TCP + IP 
       
        let mut new_packet = create_ipv4_packet(&mut int_slice, ipv4_TCPPayload );
        let addr = ipPacketCopy.get_destination();

        //We send the IP + TCP packet
        let packetDelivery = match px.send_to(new_packet, std::net::IpAddr::V4(addr)) {
            Ok(n) =>  {
                n;
            },
            Err(e) => {String::from("The packet wasnt sent. An error was detected");}, 
        }; 
}

pub fn main(){

    let sourcePort : u16 = 12345;
    let destPort : u16 = 80;

    let sourceAddress = Ipv4Addr::new(192,168,1,166);
    let destAddress = Ipv4Addr::new(142,251,46,227); 
    let veectt = Vec::new();
    let vectHexaPay = Vec::new();

    let ipPac = pnet::packet::ipv4::Ipv4{version: 4,
        header_length: 5,
        dscp: 0,
        ecn: 1,
        total_length: 60,
        identification: 15,
        flags: 2,
        fragment_offset: 0,
        ttl: 64,
        next_level_protocol: IpNextHeaderProtocol::new(6),
        checksum: 0,
        source: sourceAddress,
        destination: destAddress,
        options: veectt.clone(),
        payload: vectHexaPay.clone(), //Payload TCP 
    }; 

    let mut packetIP =[0u8; 60];

    let mut mutableIpv4Pac = MutableIpv4Packet::new(&mut packetIP).unwrap();
    mutableIpv4Pac.populate(&ipPac); 
    sendSYN(sourcePort, destPort, mutableIpv4Pac);
}