view release on metacpan or  search on metacpan

Admin.xs  view on Meta::CPAN

                     ptr = "Program"; break;
                 default:
                     ptr = "unknown security type";
                 }
                 hv_store(entry, "Security Type", 13,
                          newSVpvn(ptr, strlen(ptr)), FALSE);
             }
             len = padstrlen(dir_entry->hostname, sizeof(dir_entry->hostname));
             if (len) {
                 hv_store(entry, "HostName", 8,
                          newSVpvn(dir_entry->hostname, len), FALSE);
             }
             len = padstrlen(dir_entry->service_name, sizeof(dir_entry->service_name));
             if (len) {
                 hv_store(entry, "ServiceName", 11,
                          newSVpvn(dir_entry->service_name, len), FALSE);
             }
             len = padstrlen(dir_entry->fileserver, sizeof(dir_entry->fileserver));
             if (len) {
                 hv_store(entry, "Fileserver", 10,
                          newSVpvn(dir_entry->fileserver, len), FALSE);
             }
             len = padstrlen(dir_entry->objectname, sizeof(dir_entry->objectname));
             if (len) {
                 hv_store(entry, "ObjectName", 10,
                          newSVpvn(dir_entry->objectname, len), FALSE);
             }
             len = padstrlen(dir_entry->instance_name, sizeof(dir_entry->instance_name));
             if (len) {
                 hv_store(entry, "InstanceName", 12,
                          newSVpvn(dir_entry->instance_name, len), FALSE);
             }
             len = padstrlen(dir_entry->computername, sizeof(dir_entry->computername));
             if (len) {
                 hv_store(entry, "ComputerName", 12,
                          newSVpvn(dir_entry->computername, len), FALSE);
             }
             len = padstrlen(dir_entry->system_name, sizeof(dir_entry->system_name));
             if (len) {
                 hv_store(entry, "SystemName", 11,
                          newSVpvn(dir_entry->system_name, len), FALSE);
             }
             len = padstrlen(dir_entry->remote_instname, sizeof(dir_entry->remote_instname));
             if (len) {
                 hv_store(entry, "RemoteInstName", 14,
                          newSVpvn(dir_entry->remote_instname, len), FALSE);
             }

             /* Catalog node type: 0=normal, 2: admin */
             switch(dir_entry->catalog_node_type) {
             case 0:
                 ptr = "Normal"; break;
             case 2:
                 ptr = "Admin"; break;
             default:
                 ptr = "unknown catalog node type";
             }
             hv_store(entry, "CatalogNodeType", 15,
                      newSVpvn(ptr, strlen(ptr)), FALSE);

             /* OS type must be decoded by caller */
             hv_store(entry, "OSType", 6, newSViv(dir_entry->os_type), FALSE);

             /* Add hash to result */
             av_push(retval, newRV_noinc((SV*)entry));
         }

         sqlencls(dir_handle, &global_sqlca);
         if (global_sqlca.sqlcode != SQL_RC_OK) {
             warn("db2NodeDirectory: sqlencls() failed with sqlcode %d",
                  global_sqlca.sqlcode);
             /* Fall-through - we have results */
         }

         Return = newRV_noinc((SV*)retval);
         XPUSHs(Return);

     leave:
         /* FIXME: should clear up retval array if defined */
         if (error) {
             XSRETURN_UNDEF;
         }
     }


#
# Catalog a node
#
# Parameters:
# - Reference to a hash with relevant fields
# Returns:
# - Boolean
#
void
sqlectnd(params)
    SV *params

    PPCODE:
    {
        char                     protocol;
        struct sqle_node_struct  generic_node_info = { SQL_NODE_STR_ID, 0, "", "", 0 };
        struct sqle_node_tcpip   tcpip_node_info = { "", "" };
        struct sqle_node_local   local_node_info = { "" };
        void                    *protocol_info;
        char                    *key;
        I32                      keylen;
        SV                      *value, **elem;

        if ((!SvROK(params)) ||
            (SvTYPE(SvRV(params)) != SVt_PVHV)) {
            croak("Hash reference expected for parameter 'params'");
        }

        /* Get the 'protocol' parameter before doing anything else */
        elem = hv_fetch((HV*)SvRV(params), "Protocol", 8, FALSE);
        if (elem == NULL)
            croak("Required parameter 'Protocol' missing\n");
        if (SvPOK(*elem)) {
            char   *val;
            STRLEN  len;