fn main()

in samplecode/pcl/pcl-seal/app/src/main.rs [177:293]
103 lines of code
7 McCabe index (conditional complexity)

fn main() {
    let mut args: Vec<_> = env::args().collect();
    let mut sign_type = sgx_quote_sign_type_t::SGX_LINKABLE_SIGNATURE;
    args.remove(0);
    while !args.is_empty() {
        match args.remove(0).as_ref() {
            "--unlink" => sign_type = sgx_quote_sign_type_t::SGX_UNLINKABLE_SIGNATURE,
            _ => {
                panic!("Only --unlink is accepted");
            }
        }
    }

    let enclave = match init_enclave() {
        Ok(r) => {
            println!("[+] Init Enclave Successful {}!", r.geteid());
            r
        },
        Err(x) => {
            println!("[-] Init Enclave Failed {}!", x.as_str());
            return;
        },
    };

    println!("[+] Running as server...");
    let listener = TcpListener::bind("0.0.0.0:3443").unwrap();
    match listener.accept() {
        Ok((socket, addr)) => {
            println!("[+] new client from {:?}", addr);
            let mut retval = sgx_status_t::SGX_SUCCESS;
            let result = unsafe {
                key_provision(enclave.geteid(), &mut retval, socket.as_raw_fd(), sign_type)
            };
            match result {
                sgx_status_t::SGX_SUCCESS => {
                    println!("[+] ECALL success!");
                },
                _ => {
                    println!("[-] ECALL Enclave Failed {}!", result.as_str());
                    return;
                }
            }
            match retval {
                sgx_status_t::SGX_SUCCESS => {
                    println!("[+] provisioning successed!");
                },
                x => {
                    println!("[-] key provisioning failed! {}", x.as_str());
                },
            }
        },
        Err(e) => println!("[-] couldn't get client: {:?}", e),
    }

    let mut pcl_sealed_key_len : u32 = 0;
    let result = unsafe { get_sealed_pcl_key_len(enclave.geteid(),
                                                 &mut pcl_sealed_key_len as *mut u32) };
    if result != sgx_status_t::SGX_SUCCESS {
        println!("[-] Call get_sealed_pcl_key_len error {}", result);
    }
    println!("[+] Get sealed_pcl_key_len = {}", pcl_sealed_key_len);

    let mut sealed_key_vec: Vec<u8> = vec![0u8;pcl_sealed_key_len as usize];
    let mut retval = sgx_status_t::SGX_SUCCESS;
    let result = unsafe {
        get_sealed_pcl_key(enclave.geteid(),
                           &mut retval,
                           sealed_key_vec.as_mut_ptr(),
                           pcl_sealed_key_len)
    };

    if result != sgx_status_t::SGX_SUCCESS {
      println!("[-] Call get_sealed_pcl_key error {}", result);
    }

    if retval != sgx_status_t::SGX_SUCCESS {
        println!("[-] get_sealed_pcl_key returned error {}", retval);
    }

    println!("get_sealed_pcl_key {:02X}", sealed_key_vec.iter().format(""));

    let result = init_encrypted_enclave(ENCRYPTED_ENCLAVE_FILE,
                                        &sealed_key_vec);
    let payload_enclave = match result {
        Ok(r) => {
            println!("[+] Init Enclave Successful {}!", r.geteid());
            r
        },
        Err(x) => {
            println!("[-] Init Enclave Failed {}!", x.as_str());
            return;
        },
    };

    let mut retval : sgx_status_t = sgx_status_t::SGX_SUCCESS;
    let input_string = String::from("This is a normal world string passed into Enclave!\n");

    let result = unsafe {
        f_01ff85f39c4c46adba815dec85546b5579ad1b56(
            payload_enclave.geteid(),
            &mut retval,
            input_string.as_ptr() as * const u8,
            input_string.len())
    };

    if result != sgx_status_t::SGX_SUCCESS {
      println!("[-] Call encrypted func error {}", result);
    }

    if retval != sgx_status_t::SGX_SUCCESS {
        println!("[-] encrypted func returned error {}", retval);
    }

    println!("[+] Done!");

    enclave.destroy();
}