|
| 1 | +use core::ffi::c_void; |
| 2 | +use core::ptr::NonNull; |
| 3 | +use futures_channel::oneshot::{channel, Sender}; |
| 4 | +use nginx_sys::{ |
| 5 | + NGX_RESOLVE_FORMERR, NGX_RESOLVE_NOTIMP, NGX_RESOLVE_NXDOMAIN, NGX_RESOLVE_REFUSED, |
| 6 | + NGX_RESOLVE_SERVFAIL, NGX_RESOLVE_TIMEDOUT, |
| 7 | +}; |
| 8 | +use ngx::{ |
| 9 | + collections::Vec, |
| 10 | + core::Pool, |
| 11 | + ffi::{ |
| 12 | + ngx_addr_t, ngx_msec_t, ngx_resolve_name, ngx_resolve_start, ngx_resolver_ctx_t, |
| 13 | + ngx_resolver_t, ngx_str_t, |
| 14 | + }, |
| 15 | +}; |
| 16 | +use std::boxed::Box; |
| 17 | +use std::string::{String, ToString}; |
| 18 | + |
| 19 | +/// Error type for all uses of `Resolver`. |
| 20 | +#[derive(thiserror::Error, Debug)] |
| 21 | +pub enum Error { |
| 22 | + #[error("No resolver configured")] |
| 23 | + NoResolver, |
| 24 | + #[error("{0}: resolving `{1}`")] |
| 25 | + Resolver(ResolverError, String), |
| 26 | + #[error("Allocation failed")] |
| 27 | + AllocationFailed, |
| 28 | + #[error("Unexpected error: {0}")] |
| 29 | + Unexpected(String), |
| 30 | +} |
| 31 | + |
| 32 | +/// These cases directly reflect the NGX_RESOLVE_ error codes, |
| 33 | +/// plus a timeout, and a case for an unknown error where a known |
| 34 | +/// NGX_RESOLVE_ should be. |
| 35 | +#[derive(thiserror::Error, Debug)] |
| 36 | +pub enum ResolverError { |
| 37 | + #[error("Format error")] |
| 38 | + Format, |
| 39 | + #[error("Server failure")] |
| 40 | + Server, |
| 41 | + #[error("Host not found")] |
| 42 | + HostNotFound, |
| 43 | + #[error("Unimplemented")] |
| 44 | + Unimplemented, |
| 45 | + #[error("Operation refused")] |
| 46 | + Refused, |
| 47 | + #[error("Timed Out")] |
| 48 | + TimedOut, |
| 49 | + #[error("Unknown NGX_RESOLVE error {0}")] |
| 50 | + Unknown(isize), |
| 51 | +} |
| 52 | +/// Convert from the NGX_RESOLVE_ error codes. Fails if code was success. |
| 53 | +impl TryFrom<isize> for ResolverError { |
| 54 | + type Error = (); |
| 55 | + fn try_from(code: isize) -> Result<ResolverError, Self::Error> { |
| 56 | + match code as u32 { |
| 57 | + 0 => Err(()), |
| 58 | + NGX_RESOLVE_FORMERR => Ok(ResolverError::Format), |
| 59 | + NGX_RESOLVE_SERVFAIL => Ok(ResolverError::Server), |
| 60 | + NGX_RESOLVE_NXDOMAIN => Ok(ResolverError::HostNotFound), |
| 61 | + NGX_RESOLVE_NOTIMP => Ok(ResolverError::Unimplemented), |
| 62 | + NGX_RESOLVE_REFUSED => Ok(ResolverError::Refused), |
| 63 | + NGX_RESOLVE_TIMEDOUT => Ok(ResolverError::TimedOut), |
| 64 | + _ => Ok(ResolverError::Unknown(code)), |
| 65 | + } |
| 66 | + } |
| 67 | +} |
| 68 | + |
| 69 | +type Res = Result<Vec<ngx_addr_t>, Error>; |
| 70 | + |
| 71 | +struct ResCtx<'a> { |
| 72 | + ctx: Option<*mut ngx_resolver_ctx_t>, |
| 73 | + sender: Option<Sender<Res>>, |
| 74 | + pool: &'a mut Pool, |
| 75 | +} |
| 76 | + |
| 77 | +impl Drop for ResCtx<'_> { |
| 78 | + fn drop(&mut self) { |
| 79 | + if let Some(ctx) = self.ctx.take() { |
| 80 | + unsafe { |
| 81 | + nginx_sys::ngx_resolve_name_done(ctx); |
| 82 | + } |
| 83 | + } |
| 84 | + } |
| 85 | +} |
| 86 | + |
| 87 | +fn copy_resolved_addr( |
| 88 | + addr: *mut nginx_sys::ngx_resolver_addr_t, |
| 89 | + pool: &mut Pool, |
| 90 | +) -> Result<ngx_addr_t, Error> { |
| 91 | + let addr = NonNull::new(addr).ok_or(Error::Unexpected( |
| 92 | + "null ngx_resolver_addr_t in ngx_resolver_ctx_t.addrs".to_string(), |
| 93 | + ))?; |
| 94 | + let addr = unsafe { addr.as_ref() }; |
| 95 | + |
| 96 | + let sockaddr = pool.alloc(addr.socklen as usize) as *mut nginx_sys::sockaddr; |
| 97 | + if sockaddr.is_null() { |
| 98 | + Err(Error::AllocationFailed)?; |
| 99 | + } |
| 100 | + unsafe { |
| 101 | + addr.sockaddr |
| 102 | + .cast::<u8>() |
| 103 | + .copy_to_nonoverlapping(sockaddr.cast(), addr.socklen as usize) |
| 104 | + }; |
| 105 | + |
| 106 | + let name = unsafe { ngx_str_t::from_bytes(pool.as_mut(), addr.name.as_bytes()) } |
| 107 | + .ok_or(Error::AllocationFailed)?; |
| 108 | + |
| 109 | + Ok(ngx_addr_t { |
| 110 | + sockaddr, |
| 111 | + socklen: addr.socklen, |
| 112 | + name, |
| 113 | + }) |
| 114 | +} |
| 115 | + |
| 116 | +pub struct Resolver { |
| 117 | + resolver: NonNull<ngx_resolver_t>, |
| 118 | + timeout: ngx_msec_t, |
| 119 | +} |
| 120 | + |
| 121 | +impl Resolver { |
| 122 | + /// Create a new `Resolver` from existing pointer to `ngx_resolver_t` and |
| 123 | + /// timeout. |
| 124 | + pub fn from_resolver(resolver: NonNull<ngx_resolver_t>, timeout: ngx_msec_t) -> Self { |
| 125 | + Self { resolver, timeout } |
| 126 | + } |
| 127 | + |
| 128 | + /// Resolve a name into a set of addresses. |
| 129 | + /// |
| 130 | + /// The set of addresses may not be deterministic, because the |
| 131 | + /// implementation of the resolver may race multiple DNS requests. |
| 132 | + pub async fn resolve(&self, name: &ngx_str_t, pool: &mut Pool) -> Res { |
| 133 | + unsafe { |
| 134 | + let ctx: *mut ngx_resolver_ctx_t = |
| 135 | + ngx_resolve_start(self.resolver.as_ptr(), core::ptr::null_mut()); |
| 136 | + if ctx.is_null() { |
| 137 | + Err(Error::AllocationFailed)? |
| 138 | + } |
| 139 | + if ctx as isize == -1 { |
| 140 | + Err(Error::NoResolver)? |
| 141 | + } |
| 142 | + |
| 143 | + let (sender, receiver) = channel::<Res>(); |
| 144 | + let rctx = Box::new(ResCtx { |
| 145 | + ctx: Some(ctx), |
| 146 | + sender: Some(sender), |
| 147 | + pool, |
| 148 | + }); |
| 149 | + |
| 150 | + (*ctx).name = *name; |
| 151 | + (*ctx).timeout = self.timeout; |
| 152 | + (*ctx).set_cancelable(1); |
| 153 | + (*ctx).handler = Some(Self::resolve_handler); |
| 154 | + (*ctx).data = Box::into_raw(rctx) as *mut c_void; |
| 155 | + |
| 156 | + let ret = ngx_resolve_name(ctx); |
| 157 | + if ret != 0 { |
| 158 | + Err(Error::Resolver( |
| 159 | + ResolverError::try_from(ret).expect("nonzero, checked above"), |
| 160 | + name.to_string(), |
| 161 | + ))?; |
| 162 | + } |
| 163 | + |
| 164 | + receiver |
| 165 | + .await |
| 166 | + .map_err(|_| Error::Resolver(ResolverError::TimedOut, name.to_string()))? |
| 167 | + } |
| 168 | + } |
| 169 | + |
| 170 | + unsafe extern "C" fn resolve_handler(ctx: *mut ngx_resolver_ctx_t) { |
| 171 | + let mut rctx = *Box::from_raw((*ctx).data as *mut ResCtx); |
| 172 | + rctx.ctx.take(); |
| 173 | + if let Some(sender) = rctx.sender.take() { |
| 174 | + let _ = sender.send(Self::resolve_result(ctx, rctx.pool)); |
| 175 | + } |
| 176 | + nginx_sys::ngx_resolve_name_done(ctx); |
| 177 | + } |
| 178 | + |
| 179 | + fn resolve_result(ctx: *mut ngx_resolver_ctx_t, pool: &mut Pool) -> Res { |
| 180 | + let ctx = unsafe { ctx.as_ref().unwrap() }; |
| 181 | + let s = ctx.state; |
| 182 | + if s != 0 { |
| 183 | + Err(Error::Resolver( |
| 184 | + ResolverError::try_from(s).expect("nonzero, checked above"), |
| 185 | + ctx.name.to_string(), |
| 186 | + ))?; |
| 187 | + } |
| 188 | + if ctx.addrs.is_null() { |
| 189 | + Err(Error::AllocationFailed)?; |
| 190 | + } |
| 191 | + let mut out = Vec::new(); |
| 192 | + for i in 0..ctx.naddrs { |
| 193 | + out.push(copy_resolved_addr(unsafe { ctx.addrs.add(i) }, pool)?); |
| 194 | + } |
| 195 | + Ok(out) |
| 196 | + } |
| 197 | +} |
0 commit comments