syslog_rs/

socket.rs

/*-
 * syslog-rs - a syslog client translated from libc to rust
 * 
 * Copyright 2025 Aleksandr Morozov
 * 
 * Licensed under the EUPL, Version 1.2 or - as soon they will be approved by
 * the European Commission - subsequent versions of the EUPL (the "Licence").
 * 
 * You may not use this work except in compliance with the Licence.
 * 
 * You may obtain a copy of the Licence at:
 * 
 *    https://joinup.ec.europa.eu/software/page/eupl
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the Licence is distributed on an "AS IS" basis, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * Licence for the specific language governing permissions and limitations
 * under the Licence.
 */


use std::fmt;
use std::path::{PathBuf, Path};

#[cfg(feature = "build_with_net")]
use std::net::{SocketAddr, IpAddr, Ipv4Addr};

#[cfg(feature = "build_with_tls")]
use std::sync::Arc;

#[cfg(feature = "build_with_tls")]
use rustls::pki_types::CertificateDer;
#[cfg(feature = "build_with_tls")]
use rustls::pki_types::ServerName;
#[cfg(feature = "build_with_tls")]
use rustls::ClientConfig;
#[cfg(feature = "build_with_tls")]
use rustls::RootCertStore;

use crate::formatters::SyslogFormatter;
use crate::throw_error;
use crate::error::SyRes; 

#[cfg(feature = "build_with_net")]
use crate::map_error;

#[cfg(feature = "build_with_net")]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum TapTypeDataRemProto
{
    Tcp, Udp
}

#[derive(Clone, Debug)]
pub enum TapTypeData
{
    #[cfg(feature = "build_with_file")]
    LocalFile
    {
        file_path: PathBuf,
    },

    Local
    {
        custom_remote_path: Option<PathBuf>,
        use_alternative: bool
    },

    #[cfg(feature = "build_with_net")]
    Remote
    {
        proto: TapTypeDataRemProto,
        remote_addr: SocketAddr,
        bind_addr: SocketAddr
    },

    #[cfg(feature = "build_with_tls")]
    RemoteTls
    {
        remote_addr: SocketAddr,
        serv_name: ServerName<'static>,
        client_config: Arc<ClientConfig>
    }
}

impl fmt::Display for TapTypeData
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        match self
        {
            Self::Local{ .. } =>
                write!(f, "Local Syslog Socket"),

            #[cfg(feature = "build_with_file")]
            Self::LocalFile{ .. } => 
                write!(f, "Local File"),

            #[cfg(feature = "build_with_net")]
            Self::Remote{ .. } =>
                write!(f, "Remote"),

            #[cfg(feature = "build_with_tls")]
            Self::RemoteTls{ .. } => 
                write!(f, "RemoteTLS"),
        }
    }
}


impl TapTypeData
{
    #[inline]
    pub(crate) 
    fn is_same_variant(&self, other: &Self) -> bool
    {
        return std::mem::discriminant(self) == std::mem::discriminant(other);
    }
}



impl TapTypeData
{
    #[cfg(feature = "build_with_file")]
    pub(crate) 
    fn new_file(path: impl Into<PathBuf>) -> SyRes<Self>
    {
        return Ok(
            Self::LocalFile{ file_path: path.into() }
        );
    }

   /* #[cfg(feature = "build_with_file")]
    pub(crate) 
    fn new_queue_file(path: impl Into<PathBuf>) -> SyRes<Self>
    {
        return Ok(
            Self::QueueFile{ file_path: path.into() }
        );
    }*/

    pub(crate) 
    fn new_unix(custom_path: Option<&Path>, use_alt: bool) -> SyRes<Self>
    {
        let remote_path: Option<PathBuf> = 
            if let Some(path) = custom_path
            {
                if use_alt == false
                {
                    if path.exists() == false || path.is_file() == false
                    {
                        throw_error!("path either does not exists or not a file: '{}'", path.display());
                    }
                }

                Some(path.to_path_buf())
            }
            else
            {
                None
            };

        return Ok(
            Self::Local{ custom_remote_path: remote_path, use_alternative: use_alt }
        );
    }

    #[cfg(feature = "build_with_net")]
    pub(crate) 
    fn new_net<P>(proto: TapTypeDataRemProto, remote: P, local: Option<P>) -> SyRes<Self>
    where P: AsRef<str>
    {
        let remote_addr: SocketAddr = 
            remote
                .as_ref()
                .parse()
                .map_err(|e| 
                    map_error!("failed parsing remote addr '{}', error: '{}'", remote.as_ref(), e)
                )?;

        let bind_addr: SocketAddr = 
            if let Some(bind) = local
            {
                bind
                    .as_ref()
                    .parse()
                    .map_err(|e| 
                        map_error!("failed parsing bind addr '{}', error: '{}'", remote.as_ref(), e)
                    )?
            }
            else
            {
                SocketAddr::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 0)
            };

        return Ok(
            Self::Remote{ proto: proto, remote_addr: remote_addr, bind_addr: bind_addr }
        );
    }

    #[cfg(feature = "build_with_tls")]
    pub(crate) 
    fn new_tls<P>(remote: P, server_name: &str, cert: &[u8]) -> SyRes<Self>
    where P: AsRef<str>
    {
        use rustls::pki_types::pem::PemObject;

        let remote_addr: SocketAddr = 
            remote
                .as_ref()
                .parse()
                .map_err(|e| 
                    map_error!("failed parsing remote addr '{}', error: '{}'", remote.as_ref(), e)
                )?;

        let cert = 
            CertificateDer::from_pem_slice(cert)
                .map_err(|e|
                    map_error!("certificate parse error: '{}'", e)
                )?;

        let mut root_store = RootCertStore::empty();
        root_store
            .add(cert)
            .map_err(|e|
                map_error!("can not add root ceritficate, error: '{}'", e)
            )?;

        let serv_name = 
            server_name
                .to_string()
                .try_into()
                .map_err(|e|
                    map_error!("server name error: '{}'", e)
                )?;

        let client_config = 
            rustls::ClientConfig::builder()
                .with_root_certificates(root_store)
                .with_no_client_auth();

        return Ok(
            Self::RemoteTls{ remote_addr: remote_addr, serv_name: serv_name, client_config: Arc::new(client_config) }
        );
    }


    #[cfg(feature = "build_with_net")]
    #[allow(unused)]
    #[inline]
    pub(crate) 
    fn get_net_proto(&self) -> TapTypeDataRemProto
    {
        let Self::Remote { proto, .. } = self
            else { panic!("Assertion trap: TapTypeData is not remote, misused!") };
        
        return *proto;
    }

    #[allow(unused)]
    #[inline]
    pub(crate) 
    fn get_max_msg_length<F: SyslogFormatter>(&self) -> usize
    {
        use crate::common;

        match self
        {
            TapTypeData::Local{ .. } => 
            { 
                if *common::RFC5424_MAX_DGRAM >= common::MAXLINE
                {
                    return common::MAXLINE;
                }
                else
                {
                    return *common::RFC5424_MAX_DGRAM;
                };
            },
            TapTypeData::Remote{ proto, .. } => 
            {
                match proto
                {
                    TapTypeDataRemProto::Tcp => 
                        return common::RFC5424_TCP_MAX_PKT_LEN,
                    TapTypeDataRemProto::Udp => 
                        return common::RFC5424_UDP_MAX_PKT_LEN,
                }
            },
            TapTypeData::LocalFile{ .. } =>
                return common::MAXLINE,
            TapTypeData::RemoteTls{ .. } =>
                return common::RFC5424_TCP_MAX_PKT_LEN
        }
    }
}





/// An enum of types of the current syslog tap instance.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum TapType
{
    /// Not defined
    None, 

    /// Unprivileged socket used
    UnPriv,

    /// Privileged socket used
    Priv,

    /// A compatibility socket used
    OldLog,

    /// Custom unix datagram
    CustomLog,

    /// Writing to file directly
    LocalFile,

    /// Network UDP
    NetUdp,

    /// Network TCP
    NetTcp,

    /// Network TLS over TCP
    NetTls,
}

impl fmt::Display for TapType
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result 
    {
        match self
        {
            Self::None => 
                write!(f, "NO TYPE"),
            Self::UnPriv => 
                write!(f, "UNPRIV"),
            Self::Priv => 
                write!(f, "PRIV"),
            Self::OldLog =>
                write!(f, "OLD LOG"),
            Self::CustomLog => 
                write!(f, "CUSTOM LOG"),
            Self::LocalFile =>
                write!(f, "LOCAL FILE"),
            Self::NetUdp => 
                write!(f, "NET UDP"),
            Self::NetTcp => 
                write!(f, "NET TCP"),
            Self::NetTls => 
                write!(f, "NET TLS TCP")
        }
    }
}

impl TapType
{
    pub(crate) 
    fn is_priv(&self) -> bool
    {
        return *self == Self::Priv;
    }

    pub(crate) 
    fn is_network(&self) -> bool
    {
        return *self == Self::NetTcp || *self == Self::NetUdp;
    }

    pub(crate)
    fn is_file(&self) -> bool
    {
        return *self == Self::LocalFile;
    }

}