/* * Unix SMB/CIFS implementation. * NetApi Support * Copyright (C) Guenther Deschner 2007-2008 * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see . */ #ifndef __LIB_NETAPI_H__ #define __LIB_NETAPI_H__ #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ /**************************************************************** NET_API_STATUS ****************************************************************/ typedef enum { NET_API_STATUS_SUCCESS = 0 } NET_API_STATUS; #define ERROR_MORE_DATA ( 234L ) #define ENCRYPTED_PWLEN ( 16 ) /**************************************************************** ****************************************************************/ #ifndef _HEADER_misc struct GUID { uint32_t time_low; uint16_t time_mid; uint16_t time_hi_and_version; uint8_t clock_seq[2]; uint8_t node[6]; }; #endif /* _HEADER_misc */ #ifndef _HEADER_libnetapi #ifndef MAXSUBAUTHS #define MAXSUBAUTHS 15 /* max sub authorities in a SID */ #endif struct domsid { uint8_t sid_rev_num; uint8_t num_auths; uint8_t id_auth[6]; uint32_t sub_auths[MAXSUBAUTHS]; }; struct DOMAIN_CONTROLLER_INFO { const char * domain_controller_name; const char * domain_controller_address; uint32_t domain_controller_address_type; struct GUID domain_guid; const char * domain_name; const char * dns_forest_name; uint32_t flags; const char * dc_site_name; const char * client_site_name; }; /* bitmap NetJoinFlags */ #define NETSETUP_JOIN_DOMAIN ( 0x00000001 ) #define NETSETUP_ACCT_CREATE ( 0x00000002 ) #define NETSETUP_ACCT_DELETE ( 0x00000004 ) #define NETSETUP_WIN9X_UPGRADE ( 0x00000010 ) #define NETSETUP_DOMAIN_JOIN_IF_JOINED ( 0x00000020 ) #define NETSETUP_JOIN_UNSECURE ( 0x00000040 ) #define NETSETUP_MACHINE_PWD_PASSED ( 0x00000080 ) #define NETSETUP_DEFER_SPN_SET ( 0x00000100 ) #define NETSETUP_JOIN_DC_ACCOUNT ( 0x00000200 ) #define NETSETUP_JOIN_WITH_NEW_NAME ( 0x00000400 ) #define NETSETUP_INSTALL_INVOCATION ( 0x00040000 ) #define NETSETUP_IGNORE_UNSUPPORTED_FLAGS ( 0x10000000 ) #define FILTER_TEMP_DUPLICATE_ACCOUNT ( 0x0001 ) #define FILTER_NORMAL_ACCOUNT ( 0x0002 ) #define FILTER_INTERDOMAIN_TRUST_ACCOUNT ( 0x0008 ) #define FILTER_WORKSTATION_TRUST_ACCOUNT ( 0x0010 ) #define FILTER_SERVER_TRUST_ACCOUNT ( 0x0020 ) #define TIMEQ_FOREVER ( (uint32_t)-1L ) enum NETSETUP_JOIN_STATUS { NetSetupUnknownStatus=0, NetSetupUnjoined=1, NetSetupWorkgroupName=2, NetSetupDomainName=3 }; struct SERVER_INFO_100 { uint32_t sv100_platform_id; const char * sv100_name; }; struct SERVER_INFO_101 { uint32_t sv101_platform_id; const char * sv101_name; uint32_t sv101_version_major; uint32_t sv101_version_minor; uint32_t sv101_type; const char * sv101_comment; }; struct SERVER_INFO_102 { uint32_t sv102_platform_id; const char * sv102_name; uint32_t sv102_version_major; uint32_t sv102_version_minor; uint32_t sv102_type; const char * sv102_comment; uint32_t sv102_users; uint32_t sv102_disc; uint8_t sv102_hidden; uint32_t sv102_announce; uint32_t sv102_anndelta; uint32_t sv102_licenses; const char * sv102_userpath; }; struct SERVER_INFO_402 { uint32_t sv402_ulist_mtime; uint32_t sv402_glist_mtime; uint32_t sv402_alist_mtime; const char * sv402_alerts; uint32_t sv402_security; uint32_t sv402_numadmin; uint32_t sv402_lanmask; const char * sv402_guestacct; uint32_t sv402_chdevs; uint32_t sv402_chdevq; uint32_t sv402_chdevjobs; uint32_t sv402_connections; uint32_t sv402_shares; uint32_t sv402_openfiles; uint32_t sv402_sessopens; uint32_t sv402_sessvcs; uint32_t sv402_sessreqs; uint32_t sv402_opensearch; uint32_t sv402_activelocks; uint32_t sv402_numreqbuf; uint32_t sv402_sizreqbuf; uint32_t sv402_numbigbuf; uint32_t sv402_numfiletasks; uint32_t sv402_alertsched; uint32_t sv402_erroralert; uint32_t sv402_logonalert; uint32_t sv402_accessalert; uint32_t sv402_diskalert; uint32_t sv402_netioalert; uint32_t sv402_maxauditsz; const char * sv402_srvheuristics; }; struct SERVER_INFO_403 { uint32_t sv403_ulist_mtime; uint32_t sv403_glist_mtime; uint32_t sv403_alist_mtime; const char * sv403_alerts; uint32_t sv403_security; uint32_t sv403_numadmin; uint32_t sv403_lanmask; const char * sv403_guestacct; uint32_t sv403_chdevs; uint32_t sv403_chdevq; uint32_t sv403_chdevjobs; uint32_t sv403_connections; uint32_t sv403_shares; uint32_t sv403_openfiles; uint32_t sv403_sessopens; uint32_t sv403_sessvcs; uint32_t sv403_sessreqs; uint32_t sv403_opensearch; uint32_t sv403_activelocks; uint32_t sv403_numreqbuf; uint32_t sv403_sizreqbuf; uint32_t sv403_numbigbuf; uint32_t sv403_numfiletasks; uint32_t sv403_alertsched; uint32_t sv403_erroralert; uint32_t sv403_logonalert; uint32_t sv403_accessalert; uint32_t sv403_diskalert; uint32_t sv403_netioalert; uint32_t sv403_maxauditsz; const char * sv403_srvheuristics; uint32_t sv403_auditedevents; uint32_t sv403_autoprofile; const char * sv403_autopath; }; struct SERVER_INFO_502 { uint32_t sv502_sessopens; uint32_t sv502_sessvcs; uint32_t sv502_opensearch; uint32_t sv502_sizreqbuf; uint32_t sv502_initworkitems; uint32_t sv502_maxworkitems; uint32_t sv502_rawworkitems; uint32_t sv502_irpstacksize; uint32_t sv502_maxrawbuflen; uint32_t sv502_sessusers; uint32_t sv502_sessconns; uint32_t sv502_maxpagedmemoryusage; uint32_t sv502_maxnonpagedmemoryusage; uint8_t sv502_enablesoftcompat; uint8_t sv502_enableforcedlogoff; uint8_t sv502_timesource; uint8_t sv502_acceptdownlevelapis; uint8_t sv502_lmannounce; }; struct SERVER_INFO_503 { uint32_t sv503_sessopens; uint32_t sv503_sessvcs; uint32_t sv503_opensearch; uint32_t sv503_sizreqbuf; uint32_t sv503_initworkitems; uint32_t sv503_maxworkitems; uint32_t sv503_rawworkitems; uint32_t sv503_irpstacksize; uint32_t sv503_maxrawbuflen; uint32_t sv503_sessusers; uint32_t sv503_sessconns; uint32_t sv503_maxpagedmemoryusage; uint32_t sv503_maxnonpagedmemoryusage; uint8_t sv503_enablesoftcompat; uint8_t sv503_enableforcedlogoff; uint8_t sv503_timesource; uint8_t sv503_acceptdownlevelapis; uint8_t sv503_lmannounce; const char * sv503_domain; uint32_t sv503_maxcopyreadlen; uint32_t sv503_maxcopywritelen; uint32_t sv503_minkeepsearch; uint32_t sv503_maxkeepsearch; uint32_t sv503_minkeepcomplsearch; uint32_t sv503_maxkeepcomplsearch; uint32_t sv503_threadcountadd; uint32_t sv503_numblockthreads; uint32_t sv503_scavtimeout; uint32_t sv503_minrcvqueue; uint32_t sv503_minfreeworkitems; uint32_t sv503_xactmemsize; uint32_t sv503_threadpriority; uint32_t sv503_maxmpxct; uint32_t sv503_oplockbreakwait; uint32_t sv503_oplockbreakresponsewait; uint8_t sv503_enableoplocks; uint8_t sv503_enableoplockforceclose; uint8_t sv503_enablefcbopens; uint8_t sv503_enableraw; uint8_t sv503_enablesharednetdrives; uint32_t sv503_minfreeconnections; uint32_t sv503_maxfreeconnections; }; struct SERVER_INFO_599 { uint32_t sv599_sessopens; uint32_t sv599_sessvcs; uint32_t sv599_opensearch; uint32_t sv599_sizreqbuf; uint32_t sv599_initworkitems; uint32_t sv599_maxworkitems; uint32_t sv599_rawworkitems; uint32_t sv599_irpstacksize; uint32_t sv599_maxrawbuflen; uint32_t sv599_sessusers; uint32_t sv599_sessconns; uint32_t sv599_maxpagedmemoryusage; uint32_t sv599_maxnonpagedmemoryusage; uint8_t sv599_enablesoftcompat; uint8_t sv599_enableforcedlogoff; uint8_t sv599_timesource; uint8_t sv599_acceptdownlevelapis; uint8_t sv599_lmannounce; const char * sv599_domain; uint32_t sv599_maxcopyreadlen; uint32_t sv599_maxcopywritelen; uint32_t sv599_minkeepsearch; uint32_t sv599_maxkeepsearch; uint32_t sv599_minkeepcomplsearch; uint32_t sv599_maxkeepcomplsearch; uint32_t sv599_threadcountadd; uint32_t sv599_numblockthreads; uint32_t sv599_scavtimeout; uint32_t sv599_minrcvqueue; uint32_t sv599_minfreeworkitems; uint32_t sv599_xactmemsize; uint32_t sv599_threadpriority; uint32_t sv599_maxmpxct; uint32_t sv599_oplockbreakwait; uint32_t sv599_oplockbreakresponsewait; uint8_t sv599_enableoplocks; uint8_t sv599_enableoplockforceclose; uint8_t sv599_enablefcbopens; uint8_t sv599_enableraw; uint8_t sv599_enablesharednetdrives; uint32_t sv599_minfreeconnections; uint32_t sv599_maxfreeconnections; uint32_t sv599_initsesstable; uint32_t sv599_initconntable; uint32_t sv599_initfiletable; uint32_t sv599_initsearchtable; uint32_t sv599_alertschedule; uint32_t sv599_errorthreshold; uint32_t sv599_networkerrorthreshold; uint32_t sv599_diskspacethreshold; uint32_t sv599_reserved; uint32_t sv599_maxlinkdelay; uint32_t sv599_minlinkthroughput; uint32_t sv599_linkinfovalidtime; uint32_t sv599_scavqosinfoupdatetime; uint32_t sv599_maxworkitemidletime; }; struct SERVER_INFO_598 { uint32_t sv598_maxrawworkitems; uint32_t sv598_maxthreadsperqueue; uint32_t sv598_producttype; uint32_t sv598_serversize; uint32_t sv598_connectionlessautodisc; uint32_t sv598_sharingviolationretries; uint32_t sv598_sharingviolationdelay; uint32_t sv598_maxglobalopensearch; uint32_t sv598_removeduplicatesearches; uint32_t sv598_lockviolationoffset; uint32_t sv598_lockviolationdelay; uint32_t sv598_mdlreadswitchover; uint32_t sv598_cachedopenlimit; uint32_t sv598_otherqueueaffinity; uint8_t sv598_restrictnullsessaccess; uint8_t sv598_enablewfw311directipx; uint32_t sv598_queuesamplesecs; uint32_t sv598_balancecount; uint32_t sv598_preferredaffinity; uint32_t sv598_maxfreerfcbs; uint32_t sv598_maxfreemfcbs; uint32_t sv598_maxfreelfcbs; uint32_t sv598_maxfreepagedpoolchunks; uint32_t sv598_minpagedpoolchunksize; uint32_t sv598_maxpagedpoolchunksize; uint8_t sv598_sendsfrompreferredprocessor; uint32_t sv598_cacheddirectorylimit; uint32_t sv598_maxcopylength; uint8_t sv598_enablecompression; uint8_t sv598_autosharewks; uint8_t sv598_autoshareserver; uint8_t sv598_enablesecuritysignature; uint8_t sv598_requiresecuritysignature; uint32_t sv598_minclientbuffersize; struct GUID sv598_serverguid; uint32_t sv598_ConnectionNoSessionsTimeout; uint32_t sv598_IdleThreadTimeOut; uint8_t sv598_enableW9xsecuritysignature; uint8_t sv598_enforcekerberosreauthentication; uint8_t sv598_disabledos; uint32_t sv598_lowdiskspaceminimum; uint8_t sv598_disablestrictnamechecking; }; struct SERVER_INFO_1005 { const char * sv1005_comment; }; struct SERVER_INFO_1107 { uint32_t sv1107_users; }; struct SERVER_INFO_1010 { int32_t sv1010_disc; }; struct SERVER_INFO_1016 { uint8_t sv1016_hidden; }; struct SERVER_INFO_1017 { uint32_t sv1017_announce; }; struct SERVER_INFO_1018 { uint32_t sv1018_anndelta; }; struct SERVER_INFO_1501 { uint32_t sv1501_sessopens; }; struct SERVER_INFO_1502 { uint32_t sv1502_sessvcs; }; struct SERVER_INFO_1503 { uint32_t sv1503_opensearch; }; struct SERVER_INFO_1506 { uint32_t sv1506_maxworkitems; }; struct SERVER_INFO_1509 { uint32_t sv1509_maxrawbuflen; }; struct SERVER_INFO_1510 { uint32_t sv1510_sessusers; }; struct SERVER_INFO_1511 { uint32_t sv1511_sessconns; }; struct SERVER_INFO_1512 { uint32_t sv1512_maxnonpagedmemoryusage; }; struct SERVER_INFO_1513 { uint32_t sv1513_maxpagedmemoryusage; }; struct SERVER_INFO_1514 { uint8_t sv1514_enablesoftcompat; }; struct SERVER_INFO_1515 { uint8_t sv1515_enableforcedlogoff; }; struct SERVER_INFO_1516 { uint8_t sv1516_timesource; }; struct SERVER_INFO_1518 { uint8_t sv1518_lmannounce; }; struct SERVER_INFO_1520 { uint32_t sv1520_maxcopyreadlen; }; struct SERVER_INFO_1521 { uint32_t sv1521_maxcopywritelen; }; struct SERVER_INFO_1522 { uint32_t sv1522_minkeepsearch; }; struct SERVER_INFO_1523 { uint32_t sv1523_maxkeepsearch; }; struct SERVER_INFO_1524 { uint32_t sv1524_minkeepcomplsearch; }; struct SERVER_INFO_1525 { uint32_t sv1525_maxkeepcomplsearch; }; struct SERVER_INFO_1528 { uint32_t sv1528_scavtimeout; }; struct SERVER_INFO_1529 { uint32_t sv1529_minrcvqueue; }; struct SERVER_INFO_1530 { uint32_t sv1530_minfreeworkitems; }; struct SERVER_INFO_1533 { uint32_t sv1533_maxmpxct; }; struct SERVER_INFO_1534 { uint32_t sv1534_oplockbreakwait; }; struct SERVER_INFO_1535 { uint32_t sv1535_oplockbreakresponsewait; }; struct SERVER_INFO_1536 { uint8_t sv1536_enableoplocks; }; struct SERVER_INFO_1537 { uint8_t sv1537_enableoplockforceclose; }; struct SERVER_INFO_1538 { uint8_t sv1538_enablefcbopens; }; struct SERVER_INFO_1539 { uint8_t sv1539_enableraw; }; struct SERVER_INFO_1540 { uint8_t sv1540_enablesharednetdrives; }; struct SERVER_INFO_1541 { uint8_t sv1541_minfreeconnections; }; struct SERVER_INFO_1542 { uint8_t sv1542_maxfreeconnections; }; struct SERVER_INFO_1543 { uint32_t sv1543_initsesstable; }; struct SERVER_INFO_1544 { uint32_t sv1544_initconntable; }; struct SERVER_INFO_1545 { uint32_t sv1545_initfiletable; }; struct SERVER_INFO_1546 { uint32_t sv1546_initsearchtable; }; struct SERVER_INFO_1547 { uint32_t sv1547_alertschedule; }; struct SERVER_INFO_1548 { uint32_t sv1548_errorthreshold; }; struct SERVER_INFO_1549 { uint32_t sv1549_networkerrorthreshold; }; struct SERVER_INFO_1550 { uint32_t sv1550_diskspacethreshold; }; struct SERVER_INFO_1552 { uint32_t sv1552_maxlinkdelay; }; struct SERVER_INFO_1553 { uint32_t sv1553_minlinkthroughput; }; struct SERVER_INFO_1554 { uint32_t sv1554_linkinfovalidtime; }; struct SERVER_INFO_1555 { uint32_t sv1555_scavqosinfoupdatetime; }; struct SERVER_INFO_1556 { uint32_t sv1556_maxworkitemidletime; }; struct SERVER_INFO_1557 { uint32_t sv1557_maxrawworkitems; }; struct SERVER_INFO_1560 { uint32_t sv1560_producttype; }; struct SERVER_INFO_1561 { uint32_t sv1561_serversize; }; struct SERVER_INFO_1562 { uint32_t sv1562_connectionlessautodisc; }; struct SERVER_INFO_1563 { uint32_t sv1563_sharingviolationretries; }; struct SERVER_INFO_1564 { uint32_t sv1564_sharingviolationdelay; }; struct SERVER_INFO_1565 { uint32_t sv1565_maxglobalopensearch; }; struct SERVER_INFO_1566 { uint8_t sv1566_removeduplicatesearches; }; struct SERVER_INFO_1567 { uint32_t sv1567_lockviolationretries; }; struct SERVER_INFO_1568 { uint32_t sv1568_lockviolationoffset; }; struct SERVER_INFO_1569 { uint32_t sv1569_lockviolationdelay; }; struct SERVER_INFO_1570 { uint32_t sv1570_mdlreadswitchover; }; struct SERVER_INFO_1571 { uint32_t sv1571_cachedopenlimit; }; struct SERVER_INFO_1572 { uint32_t sv1572_criticalthreads; }; struct SERVER_INFO_1573 { uint32_t sv1573_restrictnullsessaccess; }; struct SERVER_INFO_1574 { uint32_t sv1574_enablewfw311directipx; }; struct SERVER_INFO_1575 { uint32_t sv1575_otherqueueaffinity; }; struct SERVER_INFO_1576 { uint32_t sv1576_queuesamplesecs; }; struct SERVER_INFO_1577 { uint32_t sv1577_balancecount; }; struct SERVER_INFO_1578 { uint32_t sv1578_preferredaffinity; }; struct SERVER_INFO_1579 { uint32_t sv1579_maxfreerfcbs; }; struct SERVER_INFO_1580 { uint32_t sv1580_maxfreemfcbs; }; struct SERVER_INFO_1581 { uint32_t sv1581_maxfreemlcbs; }; struct SERVER_INFO_1582 { uint32_t sv1582_maxfreepagedpoolchunks; }; struct SERVER_INFO_1583 { uint32_t sv1583_minpagedpoolchunksize; }; struct SERVER_INFO_1584 { uint32_t sv1584_maxpagedpoolchunksize; }; struct SERVER_INFO_1585 { uint8_t sv1585_sendsfrompreferredprocessor; }; struct SERVER_INFO_1586 { uint32_t sv1586_maxthreadsperqueue; }; struct SERVER_INFO_1587 { uint32_t sv1587_cacheddirectorylimit; }; struct SERVER_INFO_1588 { uint32_t sv1588_maxcopylength; }; struct SERVER_INFO_1590 { uint32_t sv1590_enablecompression; }; struct SERVER_INFO_1591 { uint32_t sv1591_autosharewks; }; struct SERVER_INFO_1592 { uint32_t sv1592_autosharewks; }; struct SERVER_INFO_1593 { uint32_t sv1593_enablesecuritysignature; }; struct SERVER_INFO_1594 { uint32_t sv1594_requiresecuritysignature; }; struct SERVER_INFO_1595 { uint32_t sv1595_minclientbuffersize; }; struct SERVER_INFO_1596 { uint32_t sv1596_ConnectionNoSessionsTimeout; }; struct SERVER_INFO_1597 { uint32_t sv1597_IdleThreadTimeOut; }; struct SERVER_INFO_1598 { uint32_t sv1598_enableW9xsecuritysignature; }; struct SERVER_INFO_1599 { uint8_t sv1598_enforcekerberosreauthentication; }; struct SERVER_INFO_1600 { uint8_t sv1598_disabledos; }; struct SERVER_INFO_1601 { uint32_t sv1598_lowdiskspaceminimum; }; struct SERVER_INFO_1602 { uint8_t sv_1598_disablestrictnamechecking; }; struct USER_INFO_0 { const char * usri0_name; }; #define USER_PRIV_GUEST ( 0 ) #define USER_PRIV_USER ( 1 ) #define USER_PRIV_ADMIN ( 2 ) struct USER_INFO_1 { const char * usri1_name; const char * usri1_password; uint32_t usri1_password_age; uint32_t usri1_priv; const char * usri1_home_dir; const char * usri1_comment; uint32_t usri1_flags; const char * usri1_script_path; }; #define AF_OP_PRINT ( 0x1 ) #define AF_OP_COMM ( 0x2 ) #define AF_OP_SERVER ( 0x4 ) #define AF_OP_ACCOUNTS ( 0x8 ) struct USER_INFO_2 { const char * usri2_name; const char * usri2_password; uint32_t usri2_password_age; uint32_t usri2_priv; const char * usri2_home_dir; const char * usri2_comment; uint32_t usri2_flags; const char * usri2_script_path; uint32_t usri2_auth_flags; const char * usri2_full_name; const char * usri2_usr_comment; const char * usri2_parms; const char * usri2_workstations; uint32_t usri2_last_logon; uint32_t usri2_last_logoff; uint32_t usri2_acct_expires; uint32_t usri2_max_storage; uint32_t usri2_units_per_week; uint8_t *usri2_logon_hours;/* [unique] */ uint32_t usri2_bad_pw_count; uint32_t usri2_num_logons; const char * usri2_logon_server; uint32_t usri2_country_code; uint32_t usri2_code_page; }; struct USER_INFO_3 { const char * usri3_name; uint32_t usri3_password_age; uint32_t usri3_priv; const char * usri3_home_dir; const char * usri3_comment; uint32_t usri3_flags; const char * usri3_script_path; uint32_t usri3_auth_flags; const char * usri3_full_name; const char * usri3_usr_comment; const char * usri3_parms; const char * usri3_workstations; uint32_t usri3_last_logon; uint32_t usri3_last_logoff; uint32_t usri3_acct_expires; uint32_t usri3_max_storage; uint32_t usri3_units_per_week; uint8_t *usri3_logon_hours;/* [unique] */ uint32_t usri3_bad_pw_count; uint32_t usri3_num_logons; const char * usri3_logon_server; uint32_t usri3_country_code; uint32_t usri3_code_page; uint32_t usri3_user_id; uint32_t usri3_primary_group_id; const char * usri3_profile; const char * usri3_home_dir_drive; uint32_t usri3_password_expired; }; struct USER_INFO_4 { const char * usri4_name; const char * usri4_password; uint32_t usri4_password_age; uint32_t usri4_priv; const char * usri4_home_dir; const char * usri4_comment; uint32_t usri4_flags; const char * usri4_script_path; uint32_t usri4_auth_flags; const char * usri4_full_name; const char * usri4_usr_comment; const char * usri4_parms; const char * usri4_workstations; uint32_t usri4_last_logon; uint32_t usri4_last_logoff; uint32_t usri4_acct_expires; uint32_t usri4_max_storage; uint32_t usri4_units_per_week; uint8_t *usri4_logon_hours;/* [unique] */ uint32_t usri4_bad_pw_count; uint32_t usri4_num_logons; const char * usri4_logon_server; uint32_t usri4_country_code; uint32_t usri4_code_page; struct domsid *usri4_user_sid;/* [unique] */ uint32_t usri4_primary_group_id; const char * usri4_profile; const char * usri4_home_dir_drive; uint32_t usri4_password_expired; }; struct USER_INFO_10 { const char * usri10_name; const char * usri10_comment; const char * usri10_usr_comment; const char * usri10_full_name; }; struct USER_INFO_11 { const char * usri11_name; const char * usri11_comment; const char * usri11_usr_comment; const char * usri11_full_name; uint32_t usri11_priv; uint32_t usri11_auth_flags; uint32_t usri11_password_age; const char * usri11_home_dir; const char * usri11_parms; uint32_t usri11_last_logon; uint32_t usri11_last_logoff; uint32_t usri11_bad_pw_count; uint32_t usri11_num_logons; const char * usri11_logon_server; uint32_t usri11_country_code; const char * usri11_workstations; uint32_t usri11_max_storage; uint32_t usri11_units_per_week; uint8_t *usri11_logon_hours;/* [unique] */ uint32_t usri11_code_page; }; struct USER_INFO_20 { const char * usri20_name; const char * usri20_full_name; const char * usri20_comment; uint32_t usri20_flags; uint32_t usri20_user_id; }; struct USER_INFO_21 { uint8_t *usri21_password; }; struct USER_INFO_22 { const char * usri22_name; uint8_t *usri22_password; uint32_t usri22_password_age; uint32_t usri22_priv; const char * usri22_home_dir; const char * usri22_comment; uint32_t usri22_flags; uint32_t usri22_script_path; uint32_t usri22_auth_flags; const char * usri22_full_name; const char * usri22_usr_comment; const char * usri22_parms; const char * usri22_workstations; uint32_t usri22_last_logon; uint32_t usri22_last_logoff; uint32_t usri22_acct_expires; uint32_t usri22_max_storage; uint32_t usri22_units_per_week; uint8_t *usri22_logon_hours;/* [unique] */ uint32_t usri22_bad_pw_count; uint32_t usri22_num_logons; const char * usri22_logon_server; uint32_t usri22_country_code; uint32_t usri22_code_page; }; struct USER_INFO_23 { const char * usri23_name; const char * usri23_full_name; const char * usri23_comment; uint32_t usri23_flags; struct domsid *usri23_user_sid;/* [unique] */ }; struct USER_INFO_1003 { const char * usri1003_password; }; struct USER_INFO_1005 { uint32_t usri1005_priv; }; struct USER_INFO_1006 { const char * usri1006_home_dir; }; struct USER_INFO_1007 { const char * usri1007_comment; }; struct USER_INFO_1008 { uint32_t usri1008_flags; }; struct USER_INFO_1009 { const char * usri1009_script_path; }; struct USER_INFO_1010 { uint32_t usri1010_auth_flags; }; struct USER_INFO_1011 { const char * usri1011_full_name; }; struct USER_INFO_1012 { const char * usri1012_usr_comment; }; struct USER_INFO_1013 { const char * usri1013_parms; }; struct USER_INFO_1014 { const char * usri1014_workstations; }; struct USER_INFO_1017 { uint32_t usri1017_acct_expires; }; struct USER_INFO_1018 { uint32_t usri1018_max_storage; }; struct USER_INFO_1020 { uint32_t usri1020_units_per_week; uint8_t *usri1020_logon_hours;/* [unique] */ }; struct USER_INFO_1023 { const char * usri1023_logon_server; }; struct USER_INFO_1024 { uint32_t usri1024_country_code; }; struct USER_INFO_1025 { uint32_t usri1025_code_page; }; struct USER_INFO_1051 { uint32_t usri1051_primary_group_id; }; struct USER_INFO_1052 { const char * usri1052_profile; }; struct USER_INFO_1053 { const char * usri1053_home_dir_drive; }; struct USER_MODALS_INFO_0 { uint32_t usrmod0_min_passwd_len; uint32_t usrmod0_max_passwd_age; uint32_t usrmod0_min_passwd_age; uint32_t usrmod0_force_logoff; uint32_t usrmod0_password_hist_len; }; struct USER_MODALS_INFO_1 { uint32_t usrmod1_role; const char * usrmod1_primary; }; struct USER_MODALS_INFO_2 { const char * usrmod2_domain_name; struct domsid *usrmod2_domain_id;/* [unique] */ }; struct USER_MODALS_INFO_3 { uint32_t usrmod3_lockout_duration; uint32_t usrmod3_lockout_observation_window; uint32_t usrmod3_lockout_threshold; }; struct USER_MODALS_INFO_1001 { uint32_t usrmod1001_min_passwd_len; }; struct USER_MODALS_INFO_1002 { uint32_t usrmod1002_max_passwd_age; }; struct USER_MODALS_INFO_1003 { uint32_t usrmod1003_min_passwd_age; }; struct USER_MODALS_INFO_1004 { uint32_t usrmod1004_force_logoff; }; struct USER_MODALS_INFO_1005 { uint32_t usrmod1005_password_hist_len; }; struct USER_MODALS_INFO_1006 { uint32_t usrmod1006_role; }; struct USER_MODALS_INFO_1007 { const char * usrmod1007_primary; }; struct NET_DISPLAY_USER { const char * usri1_name; const char * usri1_comment; uint32_t usri1_flags; const char * usri1_full_name; uint32_t usri1_user_id; uint32_t usri1_next_index; }; struct NET_DISPLAY_MACHINE { const char * usri2_name; const char * usri2_comment; uint32_t usri2_flags; uint32_t usri2_user_id; uint32_t usri2_next_index; }; struct NET_DISPLAY_GROUP { const char * grpi3_name; const char * grpi3_comment; uint32_t grpi3_group_id; uint32_t grpi3_attributes; uint32_t grpi3_next_index; }; struct GROUP_INFO_0 { const char * grpi0_name; }; struct GROUP_INFO_1 { const char * grpi1_name; const char * grpi1_comment; }; struct GROUP_INFO_2 { const char * grpi2_name; const char * grpi2_comment; uint32_t grpi2_group_id; uint32_t grpi2_attributes; }; struct GROUP_INFO_3 { const char * grpi3_name; const char * grpi3_comment; struct domsid * grpi3_group_sid; uint32_t grpi3_attributes; }; struct GROUP_INFO_1002 { const char * grpi1002_comment; }; struct GROUP_INFO_1005 { uint32_t grpi1005_attributes; }; struct GROUP_USERS_INFO_0 { const char * grui0_name; }; struct GROUP_USERS_INFO_1 { const char * grui1_name; uint32_t grui1_attributes; }; struct LOCALGROUP_INFO_0 { const char * lgrpi0_name; }; struct LOCALGROUP_INFO_1 { const char * lgrpi1_name; const char * lgrpi1_comment; }; struct LOCALGROUP_INFO_1002 { const char * lgrpi1002_comment; }; enum SID_NAME_USE { SidTypeUser=1, SidTypeGroup=2, SidTypeDomain=3, SidTypeAlias=4, SidTypeWellKnownGroup=5, SidTypeDeletedAccount=6, SidTypeInvalid=7, SidTypeUnknown=8, SidTypeComputer=9, SidTypeLabel=10 }; struct LOCALGROUP_MEMBERS_INFO_0 { struct domsid *lgrmi0_sid;/* [unique] */ }; struct LOCALGROUP_MEMBERS_INFO_1 { struct domsid *lgrmi1_sid;/* [unique] */ enum SID_NAME_USE lgrmi1_sidusage; const char * lgrmi1_name; }; struct LOCALGROUP_MEMBERS_INFO_2 { struct domsid *lgrmi2_sid;/* [unique] */ enum SID_NAME_USE lgrmi2_sidusage; const char * lgrmi2_domainandname; }; struct LOCALGROUP_MEMBERS_INFO_3 { const char * lgrmi3_domainandname; }; struct LOCALGROUP_USERS_INFO_0 { const char * lgrui0_name; }; struct TIME_OF_DAY_INFO { uint32_t tod_elapsedt; uint32_t tod_msecs; uint32_t tod_hours; uint32_t tod_mins; uint32_t tod_secs; uint32_t tod_hunds; int32_t tod_timezone; uint32_t tod_tinterval; uint32_t tod_day; uint32_t tod_month; uint32_t tod_year; uint32_t tod_weekday; }; struct SHARE_INFO_0 { const char * shi0_netname; }; struct SHARE_INFO_1 { const char * shi1_netname; uint32_t shi1_type; const char * shi1_remark; }; struct SHARE_INFO_2 { const char * shi2_netname; uint32_t shi2_type; const char * shi2_remark; uint32_t shi2_permissions; uint32_t shi2_max_uses; uint32_t shi2_current_uses; const char * shi2_path; const char * shi2_passwd; }; struct SHARE_INFO_501 { const char * shi501_netname; uint32_t shi501_type; const char * shi501_remark; uint32_t shi501_flags; }; struct SHARE_INFO_1004 { const char * shi1004_remark; }; struct SHARE_INFO_1005 { uint32_t shi1005_flags; }; struct SHARE_INFO_1006 { uint32_t shi1006_max_uses; }; struct FILE_INFO_2 { uint32_t fi2_id; }; struct FILE_INFO_3 { uint32_t fi3_id; uint32_t fi3_permissions; uint32_t fi3_num_locks; const char * fi3_pathname; const char * fi3_username; }; #endif /* _HEADER_libnetapi */ /**************************************************************** ****************************************************************/ struct libnetapi_ctx { char *debuglevel; char *error_string; char *username; char *workgroup; char *password; char *krb5_cc_env; int use_kerberos; int disable_policy_handle_cache; void *private_data; }; /**************************************************************** ****************************************************************/ NET_API_STATUS libnetapi_init(struct libnetapi_ctx **ctx); /**************************************************************** ****************************************************************/ NET_API_STATUS libnetapi_free(struct libnetapi_ctx *ctx); /**************************************************************** ****************************************************************/ NET_API_STATUS libnetapi_getctx(struct libnetapi_ctx **ctx); /**************************************************************** ****************************************************************/ NET_API_STATUS libnetapi_set_debuglevel(struct libnetapi_ctx *ctx, const char *debuglevel); /**************************************************************** ****************************************************************/ NET_API_STATUS libnetapi_set_username(struct libnetapi_ctx *ctx, const char *username); /**************************************************************** ****************************************************************/ NET_API_STATUS libnetapi_set_password(struct libnetapi_ctx *ctx, const char *password); /**************************************************************** ****************************************************************/ NET_API_STATUS libnetapi_set_workgroup(struct libnetapi_ctx *ctx, const char *workgroup); /**************************************************************** ****************************************************************/ NET_API_STATUS libnetapi_set_use_kerberos(struct libnetapi_ctx *ctx); /**************************************************************** ****************************************************************/ const char *libnetapi_errstr(NET_API_STATUS status); /**************************************************************** ****************************************************************/ const char *libnetapi_get_error_string(struct libnetapi_ctx *ctx, NET_API_STATUS status); /**************************************************************** NetApiBufferAllocate ****************************************************************/ NET_API_STATUS NetApiBufferAllocate(uint32_t byte_count, void **buffer); /**************************************************************** NetApiBufferFree ****************************************************************/ NET_API_STATUS NetApiBufferFree(void *buffer); /************************************************************//** * * ConvertSidToStringSid * * @brief Convert a domain sid into a string * * @param[in] sid A pointer to a sid structure * @param[in,out] sid_string A pointer that holds a pointer to a sid string. Caller * needs to free with free(3) * @return bool ***************************************************************/ int ConvertSidToStringSid(const struct domsid *sid, char **sid_string); /************************************************************//** * * ConvertStringSidToSid * * @brief Convert a string into a domain sid * * @param[in] sid_string A pointer to a sid string. * @param[in,out] sid A pointer that holds a pointer to a sid structure. * Caller needs to free with free(3) * @return bool ***************************************************************/ int ConvertStringSidToSid(const char *sid_string, struct domsid **sid); /************************************************************//** * * NetJoinDomain * * @brief Join a computer to a domain or workgroup * * @param[in] server The server name to connect to * @param[in] domain The domain or workgroup to join * @param[in] account_ou The organizational Unit to create the computer account * in (AD only) * @param[in] account The domain account used for joining a domain * @param[in] password The domain account's password used for joining a domain * @param[in] join_flags Bitmask field to define specific join features * @return NET_API_STATUS * * example netdomjoin/netdomjoin.c ***************************************************************/ NET_API_STATUS NetJoinDomain(const char * server /* [in] */, const char * domain /* [in] [ref] */, const char * account_ou /* [in] */, const char * account /* [in] */, const char * password /* [in] */, uint32_t join_flags /* [in] */); /************************************************************//** * * NetUnjoinDomain * * @brief Unjoin a computer from a domain or workgroup * * @param[in] server_name The server name to connect to * @param[in] account The domain account used for unjoining a domain * @param[in] password The domain account's password used for unjoining a domain * @param[in] unjoin_flags Bitmask field to define specific unjoin features * @return NET_API_STATUS * ***************************************************************/ NET_API_STATUS NetUnjoinDomain(const char * server_name /* [in] */, const char * account /* [in] */, const char * password /* [in] */, uint32_t unjoin_flags /* [in] */); /************************************************************//** * * NetGetJoinInformation * * @brief Unjoin a computer from a domain or workgroup * * @param[in] server_name The server name to connect to * @param[out] name_buffer Returns the name of the workgroup or domain * @param[out] name_type Returns the type of that name * @return NET_API_STATUS * * example netdomjoin-gui/netdomjoin-gui.c * ***************************************************************/ NET_API_STATUS NetGetJoinInformation(const char * server_name /* [in] */, const char * *name_buffer /* [out] [ref] */, uint16_t *name_type /* [out] [ref] */); /************************************************************//** * * NetGetJoinableOUs * * @brief Query for the list of joinable organizational Units that can be used * for joining AD * * @param[in] server_name The server name to connect to * @param[in] domain The AD domain to query * @param[in] account The domain account used for the query * @param[in] password The domain account's password used for the query * @param[out] ou_count The number of ous returned * @param[out] ous Returned string array containing the ous * @return NET_API_STATUS * * example netdomjoin-gui/netdomjoin-gui.c * ***************************************************************/ NET_API_STATUS NetGetJoinableOUs(const char * server_name /* [in] */, const char * domain /* [in] [ref] */, const char * account /* [in] */, const char * password /* [in] */, uint32_t *ou_count /* [out] [ref] */, const char * **ous /* [out] [ref] */); /************************************************************//** * * NetRenameMachineInDomain * * @brief Rename a machine in a domain * * @param[in] server_name The server name to connect to * @param[in] new_machine_name The new machine name * @param[in] account The domain account used for the query * @param[in] password The domain account's password used for the query * @param[in] rename_options Options used for the rename operation * @return NET_API_STATUS * * example join/rename_machine.c * ***************************************************************/ NET_API_STATUS NetRenameMachineInDomain(const char * server_name /* [in] */, const char * new_machine_name /* [in] */, const char * account /* [in] */, const char * password /* [in] */, uint32_t rename_options /* [in] */); /************************************************************//** * * NetServerGetInfo * * @brief Get Information on a server * * @param[in] server_name The server name to connect to * @param[in] level The level to define which information is requested * @param[out] buffer The returned buffer carrying the SERVER_INFO structure * @return NET_API_STATUS * ***************************************************************/ NET_API_STATUS NetServerGetInfo(const char * server_name /* [in] */, uint32_t level /* [in] */, uint8_t **buffer /* [out] [ref] */); /************************************************************//** * * NetServerSetInfo * * @brief Get Information on a server * * @param[in] server_name The server name to connect to * @param[in] level The level to define which information is set * @param[in] buffer The buffer carrying the SERVER_INFO structure * @param[out] parm_error On failure returns the invalid SERVER_INFO member * @return NET_API_STATUS * ***************************************************************/ NET_API_STATUS NetServerSetInfo(const char * server_name /* [in] */, uint32_t level /* [in] */, uint8_t *buffer /* [in] [ref] */, uint32_t *parm_error /* [out] [ref] */); /************************************************************//** * * NetGetDCName * * @brief Query for the PDC for a given domain * * @param[in] server_name The server name to connect to * @param[in] domain_name The name of the domain to lookup * @param[out] buffer The name of the domain to lookup * @return NET_API_STATUS * * example getdc/getdc.c ***************************************************************/ NET_API_STATUS NetGetDCName(const char * server_name /* [in] */, const char * domain_name /* [in] */, uint8_t **buffer /* [out] [ref] */); /************************************************************//** * * NetGetAnyDCName * * @brief Query for any DC for a given domain * * @param[in] server_name The server name to connect to * @param[in] domain_name The name of the domain to lookup * @param[out] buffer The name of the domain to lookup * @return NET_API_STATUS * * example getdc/getdc.c ***************************************************************/ NET_API_STATUS NetGetAnyDCName(const char * server_name /* [in] */, const char * domain_name /* [in] */, uint8_t **buffer /* [out] [ref] */); /************************************************************//** * * DsGetDcName * * @brief Lookup a DC for a given domain and return information structure * * @param[in] server_name The server name to connect to * @param[in] domain_name The name of the domain to lookup (cannot be NULL) * @param[in] domain_guid The GUID of the domain to lookup (optional) * @param[in] site_name The name of the site the DC should reside in * @param[in] flags A bitmask to request specific features supported by the DC * @param[out] dc_info Pointer to a DOMAIN_CONTROLLER_INFO structure * @return NET_API_STATUS * * example dsgetdc/dsgetdc.c ***************************************************************/ NET_API_STATUS DsGetDcName(const char * server_name /* [in] [unique] */, const char * domain_name /* [in] [ref] */, struct GUID *domain_guid /* [in] [unique] */, const char * site_name /* [in] [unique] */, uint32_t flags /* [in] */, struct DOMAIN_CONTROLLER_INFO **dc_info /* [out] [ref] */); /************************************************************//** * * NetUserAdd * * @brief Create a user on a given server * * @param[in] server_name The server name to connect to * @param[in] level The level of the USER_INFO structure passed in (Currently * only level 1 is supported) * @param[in] buffer The buffer carrying the USER_INFO structure * @param[out] parm_error In case of error returns the failing member of the * structure * @return NET_API_STATUS * * example user/user_add.c ***************************************************************/ NET_API_STATUS NetUserAdd(const char * server_name /* [in] */, uint32_t level /* [in] */, uint8_t *buffer /* [in] [ref] */, uint32_t *parm_error /* [out] [ref] */); /************************************************************//** * * NetUserDel * * @brief Delete a user on a given server * * @param[in] server_name The server name to connect to * @param[in] user_name The user account to delete * @return NET_API_STATUS * * example user/user_del.c ***************************************************************/ NET_API_STATUS NetUserDel(const char * server_name /* [in] */, const char * user_name /* [in] */); /************************************************************//** * * NetUserEnum * * @brief Enumerate accounts on a server * * @param[in] server_name The server name to connect to * @param[in] level The enumeration level used for the query (Currently only * level 0 is supported) * @param[in] filter The account flags filter used for the query * @param[out] buffer The returned enumeration buffer * @param[in] prefmaxlen The requested maximal buffer size * @param[out] entries_read The number of returned entries * @param[out] total_entries The number of total entries * @param[in,out] resume_handle A handle passed in and returned for resuming * operations * @return NET_API_STATUS * * example user/user_enum.c ***************************************************************/ NET_API_STATUS NetUserEnum(const char * server_name /* [in] */, uint32_t level /* [in] */, uint32_t filter /* [in] */, uint8_t **buffer /* [out] [ref] */, uint32_t prefmaxlen /* [in] */, uint32_t *entries_read /* [out] [ref] */, uint32_t *total_entries /* [out] [ref] */, uint32_t *resume_handle /* [in,out] [ref] */); /************************************************************//** * * NetUserChangePassword * * @brief Change the password for a user on a given server or in a given domain * * @param[in] domain_name The server or domain name to connect to * @param[in] user_name The user account to change the password for * @param[in] old_password The user account's old password * @param[in] new_password The user account's new password * @return NET_API_STATUS * * example user/user_chgpwd.c ***************************************************************/ NET_API_STATUS NetUserChangePassword(const char * domain_name /* [in] */, const char * user_name /* [in] */, const char * old_password /* [in] */, const char * new_password /* [in] */); /************************************************************//** * * NetUserGetInfo * * @brief Get User Information * * @param[in] server_name The server name to connect to * @param[in] user_name The name of the user that is going to be queried * @param[in] level The level defining the requested USER_INFO_X structure * @param[out] buffer The buffer containing a USER_INFO_X structure * @return NET_API_STATUS * * example user/user_getinfo.c ***************************************************************/ NET_API_STATUS NetUserGetInfo(const char * server_name /* [in] */, const char * user_name /* [in] */, uint32_t level /* [in] */, uint8_t **buffer /* [out] [ref] */); /************************************************************//** * * NetUserSetInfo * * @brief Set User Information * * @param[in] server_name The server name to connect to * @param[in] user_name The name of the user that is going to be modified * @param[in] level The level defining the requested USER_INFO_X structure * @param[in] buffer The buffer containing a USER_INFO_X structure * @param[out] parm_err The returned parameter error number if any * @return NET_API_STATUS * * example user/user_setinfo.c ***************************************************************/ NET_API_STATUS NetUserSetInfo(const char * server_name /* [in] */, const char * user_name /* [in] */, uint32_t level /* [in] */, uint8_t *buffer /* [in] [ref] */, uint32_t *parm_err /* [out] [ref] */); /************************************************************//** * * NetUserModalsGet * * @brief Get SAM domain and password information * * @param[in] server_name The server name to connect to * @param[in] level The level defining which USER_MODALS_INFO_X buffer to query * @param[out] buffer The returned USER_MODALS_INFO_X buffer * @return NET_API_STATUS * * example user/user_modalsget.c ***************************************************************/ NET_API_STATUS NetUserModalsGet(const char * server_name /* [in] */, uint32_t level /* [in] */, uint8_t **buffer /* [out] [ref] */); /************************************************************//** * * NetUserModalsSet * * @brief Set SAM domain and password information * * @param[in] server_name The server name to connect to * @param[in] level The level defining which USER_MODALS_INFO_X buffer to query * @param[out] buffer The buffer conntaing a USER_MODALS_INFO_X structure * @param[out] parm_err The returned parameter error number if any * @return NET_API_STATUS * * example user/user_modalsset.c ***************************************************************/ NET_API_STATUS NetUserModalsSet(const char * server_name /* [in] */, uint32_t level /* [in] */, uint8_t *buffer /* [in] [ref] */, uint32_t *parm_err /* [out] [ref] */); /************************************************************//** * * NetUserGetGroups * * @brief Enumerate grouplist of a user on a server * * @param[in] server_name The server name to connect to * @param[in] user_name The user name to query * @param[in] level The enumeration level used for the query (Currently only * level 0 is supported) * @param[out] buffer The returned enumeration buffer * @param[in] prefmaxlen The requested maximal buffer size * @param[out] entries_read The number of returned entries * @param[out] total_entries The number of total entries * @return NET_API_STATUS * * example user/user_getgroups.c ***************************************************************/ NET_API_STATUS NetUserGetGroups(const char * server_name /* [in] */, const char * user_name /* [in] */, uint32_t level /* [in] */, uint8_t **buffer /* [out] [ref] */, uint32_t prefmaxlen /* [in] */, uint32_t *entries_read /* [out] [ref] */, uint32_t *total_entries /* [out] [ref] */); /************************************************************//** * * NetUserSetGroups * * @brief Set grouplist of a user on a server * * @param[in] server_name The server name to connect to * @param[in] user_name The user name to query * @param[in] level The level defining the GROUP_USERS_INFO_X structures in the buffer * @param[in] buffer The buffer containing GROUP_USERS_INFO_X structures * @param[in] num_entries The number of X structures in the buffer * @return NET_API_STATUS * * example user/user_setgroups.c ***************************************************************/ NET_API_STATUS NetUserSetGroups(const char * server_name /* [in] */, const char * user_name /* [in] */, uint32_t level /* [in] */, uint8_t *buffer /* [in] [ref] */, uint32_t num_entries /* [in] */); /************************************************************//** * * NetUserGetLocalGroups * * @brief Enumerate local grouplist of a user on a server * * @param[in] server_name The server name to connect to * @param[in] user_name The user name to query * @param[in] level The enumeration level used for the query * @param[in] flags The flags used for the query * @param[out] buffer The returned enumeration buffer * @param[in] prefmaxlen The requested maximal buffer size * @param[out] entries_read The number of returned entries * @param[out] total_entries The number of total entries * @return NET_API_STATUS * * example user/user_getlocalgroups.c ***************************************************************/ NET_API_STATUS NetUserGetLocalGroups(const char * server_name /* [in] */, const char * user_name /* [in] */, uint32_t level /* [in] */, uint32_t flags /* [in] */, uint8_t **buffer /* [out] [ref] */, uint32_t prefmaxlen /* [in] */, uint32_t *entries_read /* [out] [ref] */, uint32_t *total_entries /* [out] [ref] */); /************************************************************//** * * NetQueryDisplayInformation * * @brief Enumerate accounts on a server * * @param[in] server_name The server name to connect to * @param[in] level The enumeration level used for the query * @param[in] idx The index to start the the display enumeration at * @param[in] entries_requested The number of entries requested * @param[in] prefmaxlen The requested maximal buffer size * @param[out] entries_read The number of returned entries * @param[out] buffer The returned display information buffer * @return NET_API_STATUS * * example user/user_dispinfo.c ***************************************************************/ NET_API_STATUS NetQueryDisplayInformation(const char * server_name /* [in] [unique] */, uint32_t level /* [in] */, uint32_t idx /* [in] */, uint32_t entries_requested /* [in] */, uint32_t prefmaxlen /* [in] */, uint32_t *entries_read /* [out] [ref] */, void **buffer /* [out] [noprint,ref] */); /************************************************************//** * * NetGroupAdd * * @brief Create Domain Group * * @param[in] server_name The server name to connect to * @param[in] level The level used for the new group creation * @param[in] buf The buffer containing the group structure * @param[out] parm_err The returned parameter error number if any * @return NET_API_STATUS * * example group/group_add.c ***************************************************************/ NET_API_STATUS NetGroupAdd(const char * server_name /* [in] */, uint32_t level /* [in] */, uint8_t *buf /* [in] [ref] */, uint32_t *parm_err /* [out] [ref] */); /************************************************************//** * * NetGroupDel * * @brief Delete Domain Group * * @param[in] server_name The server name to connect to * @param[in] group_name The name of the group that is going to be deleted * @return NET_API_STATUS * * example group/group_del.c ***************************************************************/ NET_API_STATUS NetGroupDel(const char * server_name /* [in] */, const char * group_name /* [in] */); /************************************************************//** * * NetGroupEnum * * @brief Enumerate groups on a server * * @param[in] server_name The server name to connect to * @param[in] level The enumeration level used for the query (Currently only * level 0 is supported) * @param[out] buffer The returned enumeration buffer * @param[in] prefmaxlen The requested maximal buffer size * @param[out] entries_read The number of returned entries * @param[out] total_entries The number of total entries * @param[in,out] resume_handle A handle passed in and returned for resuming * operations * @return NET_API_STATUS * * example group/group_enum.c ***************************************************************/ NET_API_STATUS NetGroupEnum(const char * server_name /* [in] */, uint32_t level /* [in] */, uint8_t **buffer /* [out] [ref] */, uint32_t prefmaxlen /* [in] */, uint32_t *entries_read /* [out] [ref] */, uint32_t *total_entries /* [out] [ref] */, uint32_t *resume_handle /* [in,out] [ref] */); /************************************************************//** * * NetGroupSetInfo * * @brief Set Domain Group Information * * @param[in] server_name The server name to connect to * @param[in] group_name The name of the group that is going to be modified * @param[in] level The level defining the structure type in buf * @param[in] buf The buffer containing a GROUP_INFO_X structure * @param[out] parm_err The returned parameter error number if any * @return NET_API_STATUS * * example group/group_setinfo.c ***************************************************************/ NET_API_STATUS NetGroupSetInfo(const char * server_name /* [in] */, const char * group_name /* [in] */, uint32_t level /* [in] */, uint8_t *buf /* [in] [ref] */, uint32_t *parm_err /* [out] [ref] */); /************************************************************//** * * NetGroupGetInfo * * @brief Get Domain Group Information * * @param[in] server_name The server name to connect to * @param[in] group_name The name of the group that is going to be queried * @param[in] level The level defining the requested GROUP_INFO_X structure * @param[out] buf The buffer containing a GROUP_INFO_X structure * @return NET_API_STATUS * * example group/group_getinfo.c ***************************************************************/ NET_API_STATUS NetGroupGetInfo(const char * server_name /* [in] */, const char * group_name /* [in] */, uint32_t level /* [in] */, uint8_t **buf /* [out] [ref] */); /************************************************************//** * * NetGroupAddUser * * @brief Add existing User to existing Domain Group * * @param[in] server_name The server name to connect to * @param[in] group_name The name of the group that is going to be modified * @param[in] user_name The name of the user that is going to be added to the * group * @return NET_API_STATUS * * example group/group_adduser.c ***************************************************************/ NET_API_STATUS NetGroupAddUser(const char * server_name /* [in] */, const char * group_name /* [in] */, const char * user_name /* [in] */); /************************************************************//** * * NetGroupDelUser * * @brief Remove User from Domain Group * * @param[in] server_name The server name to connect to * @param[in] group_name The name of the group that is going to be modified * @param[in] user_name The name of the user that is going to be removed from * the group * @return NET_API_STATUS * * example group/group_deluser.c ***************************************************************/ NET_API_STATUS NetGroupDelUser(const char * server_name /* [in] */, const char * group_name /* [in] */, const char * user_name /* [in] */); /************************************************************//** * * NetGroupGetUsers * * @brief Get Users for a group on a server * * @param[in] server_name The server name to connect to * @param[in] group_name The group name to enumerate users for * @param[in] level The enumeration level used for the query * @param[out] buffer The returned enumeration buffer * @param[in] prefmaxlen The requested maximal buffer size * @param[out] entries_read The number of returned entries * @param[out] total_entries The number of total entries * @param[in,out] resume_handle A handle passed in and returned for resuming * operations * @return NET_API_STATUS * * example group/group_getusers.c ***************************************************************/ NET_API_STATUS NetGroupGetUsers(const char * server_name /* [in] */, const char * group_name /* [in] */, uint32_t level /* [in] */, uint8_t **buffer /* [out] [ref] */, uint32_t prefmaxlen /* [in] */, uint32_t *entries_read /* [out] [ref] */, uint32_t *total_entries /* [out] [ref] */, uint32_t *resume_handle /* [in,out] [ref] */); /************************************************************//** * * NetGroupSetUsers * * @brief Set Users for a group on a server * * @param[in] server_name The server name to connect to * @param[in] group_name The group name to enumerate users for * @param[in] level The enumeration level used for the query * @param[in] buffer The buffer containing a X structure * @param[in] num_entries The number of X entries in the buffer * @return NET_API_STATUS * * example group/group_setusers.c ***************************************************************/ NET_API_STATUS NetGroupSetUsers(const char * server_name /* [in] */, const char * group_name /* [in] */, uint32_t level /* [in] */, uint8_t *buffer /* [in] [ref] */, uint32_t num_entries /* [in] */); /************************************************************//** * * NetLocalGroupAdd * * @brief Create Local Group * * @param[in] server_name The server name to connect to * @param[in] level The level used for the new group creation * @param[in] buf The buffer containing the group structure * @param[out] parm_err The returned parameter error number if any * @return NET_API_STATUS * * example localgroup/localgroup_add.c ***************************************************************/ NET_API_STATUS NetLocalGroupAdd(const char * server_name /* [in] */, uint32_t level /* [in] */, uint8_t *buf /* [in] [ref] */, uint32_t *parm_err /* [out] [ref] */); /************************************************************//** * * NetLocalGroupDel * * @brief Delete Local Group * * @param[in] server_name The server name to connect to * @param[in] group_name The name of the group that is going to be deleted * @return NET_API_STATUS * * example localgroup/localgroup_del.c ***************************************************************/ NET_API_STATUS NetLocalGroupDel(const char * server_name /* [in] */, const char * group_name /* [in] */); /************************************************************//** * * NetLocalGroupGetInfo * * @brief Get Local Group Information * * @param[in] server_name The server name to connect to * @param[in] group_name The name of the group that is going to be queried * @param[in] level The level defining the requested LOCALGROUP_INFO_X structure * @param[out] buf The buffer containing a LOCALGROUP_INFO_X structure * @return NET_API_STATUS * * example localgroup/localgroup_getinfo.c ***************************************************************/ NET_API_STATUS NetLocalGroupGetInfo(const char * server_name /* [in] */, const char * group_name /* [in] */, uint32_t level /* [in] */, uint8_t **buf /* [out] [ref] */); /************************************************************//** * * NetLocalGroupSetInfo * * @brief Set Local Group Information * * @param[in] server_name The server name to connect to * @param[in] group_name The name of the group that is going to be modified * @param[in] level The level defining the requested LOCALGROUP_INFO_X structure * @param[in] buf The buffer containing a LOCALGROUP_INFO_X structure * @param[out] parm_err The returned parameter error number if any * @return NET_API_STATUS * * example localgroup/localgroup_setinfo.c ***************************************************************/ NET_API_STATUS NetLocalGroupSetInfo(const char * server_name /* [in] */, const char * group_name /* [in] */, uint32_t level /* [in] */, uint8_t *buf /* [in] [ref] */, uint32_t *parm_err /* [out] [ref] */); /************************************************************//** * * NetLocalGroupEnum * * @brief Enumerate local groups on a server * * @param[in] server_name The server name to connect to * @param[in] level The enumeration level used for the query (Currently only * level 0 is supported) * @param[out] buffer The returned enumeration buffer * @param[in] prefmaxlen The requested maximal buffer size * @param[out] entries_read The number of returned entries * @param[out] total_entries The number of total entries * @param[in,out] resume_handle A handle passed in and returned for resuming * operations * @return NET_API_STATUS * * example localgroup/localgroup_enum.c ***************************************************************/ NET_API_STATUS NetLocalGroupEnum(const char * server_name /* [in] */, uint32_t level /* [in] */, uint8_t **buffer /* [out] [ref] */, uint32_t prefmaxlen /* [in] */, uint32_t *entries_read /* [out] [ref] */, uint32_t *total_entries /* [out] [ref] */, uint32_t *resume_handle /* [in,out] [ref] */); /************************************************************//** * * NetLocalGroupAddMembers * * @brief Add Members to a Local Group * * @param[in] server_name The server name to connect to * @param[in] group_name The name of the group that is going to modified * @param[in] level The level defining the LOCALGROUP_MEMBERS_INFO_X structure * @param[in] buffer The buffer containing a LOCALGROUP_MEMBERS_INFO_X structure * @param[in] total_entries The number of LOCALGROUP_MEMBERS_INFO_X entries in * the buffer * @return NET_API_STATUS * * example localgroup/localgroup_addmembers.c ***************************************************************/ NET_API_STATUS NetLocalGroupAddMembers(const char * server_name /* [in] */, const char * group_name /* [in] */, uint32_t level /* [in] */, uint8_t *buffer /* [in] [ref] */, uint32_t total_entries /* [in] */); /************************************************************//** * * NetLocalGroupDelMembers * * @brief Delete Members from a Local Group * * @param[in] server_name The server name to connect to * @param[in] group_name The name of the group that is going to modified * @param[in] level The level defining the LOCALGROUP_MEMBERS_INFO_X structure * @param[in] buffer The buffer containing a LOCALGROUP_MEMBERS_INFO_X structure * @param[in] total_entries The number of LOCALGROUP_MEMBERS_INFO_X entries in * the buffer * @return NET_API_STATUS * * example localgroup/localgroup_delmembers.c ***************************************************************/ NET_API_STATUS NetLocalGroupDelMembers(const char * server_name /* [in] */, const char * group_name /* [in] */, uint32_t level /* [in] */, uint8_t *buffer /* [in] [ref] */, uint32_t total_entries /* [in] */); /************************************************************//** * * NetLocalGroupGetMembers * * @brief Enumerate Members in a local group * * @param[in] server_name The server name to connect to * @param[in] local_group_name The localgroup that is going to be queried * @param[in] level The level defining the LOCALGROUP_MEMBERS_INFO_X structure * @param[out] buffer The buffer containing a LOCALGROUP_MEMBERS_INFO_X * structure * @param[in] prefmaxlen The requested maximal buffer size * @param[out] entries_read The number of LOCALGROUP_MEMBERS_INFO_X entries in the buffer * @param[out] total_entries The total number of LOCALGROUP_MEMBERS_INFO_X entries for that group * @param[in,out] resume_handle A handle passed in and returned for resuming * operations * @return NET_API_STATUS * * example localgroup/localgroup_getmembers.c ***************************************************************/ NET_API_STATUS NetLocalGroupGetMembers(const char * server_name /* [in] */, const char * local_group_name /* [in] */, uint32_t level /* [in] */, uint8_t **buffer /* [out] [ref] */, uint32_t prefmaxlen /* [in] */, uint32_t *entries_read /* [out] [ref] */, uint32_t *total_entries /* [out] [ref] */, uint32_t *resume_handle /* [in,out] [ref] */); /************************************************************//** * * NetLocalGroupSetMembers * * @brief Set Members in a Local Group * * @param[in] server_name The server name to connect to * @param[in] group_name The name of the group that is going to modified * @param[in] level The level defining the LOCALGROUP_MEMBERS_INFO_X structure * @param[in] buffer The buffer containing a LOCALGROUP_MEMBERS_INFO_X structure * @param[in] total_entries The number of LOCALGROUP_MEMBERS_INFO_X entries in * the buffer * @return NET_API_STATUS * * example localgroup/localgroup_setmembers.c ***************************************************************/ NET_API_STATUS NetLocalGroupSetMembers(const char * server_name /* [in] */, const char * group_name /* [in] */, uint32_t level /* [in] */, uint8_t *buffer /* [in] [ref] */, uint32_t total_entries /* [in] */); /************************************************************//** * * NetRemoteTOD * * @brief Query remote Time of Day * * @param[in] server_name The server name to connect to * @param[out] buf The buffer containing a TIME_OF_DAY_INFO structure * @return NET_API_STATUS * * example server/remote_tod.c ***************************************************************/ NET_API_STATUS NetRemoteTOD(const char * server_name /* [in] */, uint8_t **buf /* [out] [ref] */); /************************************************************//** * * NetShareAdd * * @brief Add Share * * @param[in] server_name The server name to connect to * @param[in] level The level defining the requested SHARE_INFO_X structure * @param[in] buffer The buffer containing a SHARE_INFO_X structure * @param[out] parm_err The returned parameter error number if any * @return NET_API_STATUS * * example share/share_add.c ***************************************************************/ NET_API_STATUS NetShareAdd(const char * server_name /* [in] */, uint32_t level /* [in] */, uint8_t *buffer /* [in] [ref] */, uint32_t *parm_err /* [out] [ref] */); /************************************************************//** * * NetShareDel * * @brief Delete Share * * @param[in] server_name The server name to connect to * @param[in] net_name The name of the share to delete * @param[in] reserved * @return NET_API_STATUS * * example share/share_del.c ***************************************************************/ NET_API_STATUS NetShareDel(const char * server_name /* [in] */, const char * net_name /* [in] */, uint32_t reserved /* [in] */); /************************************************************//** * * NetShareEnum * * @brief Enumerate Shares * * @param[in] server_name The server name to connect to * @param[in] level The level defining the SHARE_INFO_X structure * @param[out] buffer The buffer containing a SHARE_INFO_X structure * @param[in] prefmaxlen The requested maximal buffer size * @param[out] entries_read The number of SHARE_INFO_X entries in the buffer * @param[out] total_entries The total number of SHARE_INFO_X entries * @param[in,out] resume_handle A handle passed in and returned for resuming * operations * @return NET_API_STATUS * * example share/share_enum.c ***************************************************************/ NET_API_STATUS NetShareEnum(const char * server_name /* [in] */, uint32_t level /* [in] */, uint8_t **buffer /* [out] [ref] */, uint32_t prefmaxlen /* [in] */, uint32_t *entries_read /* [out] [ref] */, uint32_t *total_entries /* [out] [ref] */, uint32_t *resume_handle /* [in,out] [ref] */); /************************************************************//** * * NetShareGetInfo * * @brief Get Share Info * * @param[in] server_name The server name to connect to * @param[in] net_name The name of the share to query * @param[in] level The level defining the SHARE_INFO_X structure * @param[out] buffer The buffer containing a SHARE_INFO_X structure * @return NET_API_STATUS * * example share/share_getinfo.c ***************************************************************/ NET_API_STATUS NetShareGetInfo(const char * server_name /* [in] */, const char * net_name /* [in] */, uint32_t level /* [in] */, uint8_t **buffer /* [out] [ref] */); /************************************************************//** * * NetShareSetInfo * * @brief Set Share Info * * @param[in] server_name The server name to connect to * @param[in] net_name The name of the share to query * @param[in] level The level defining the SHARE_INFO_X structure * @param[in] buffer The buffer containing a SHARE_INFO_X structure * @param[out] parm_err The returned parameter error number if any * @return NET_API_STATUS * * example share/share_setinfo.c ***************************************************************/ NET_API_STATUS NetShareSetInfo(const char * server_name /* [in] */, const char * net_name /* [in] */, uint32_t level /* [in] */, uint8_t *buffer /* [in] [ref] */, uint32_t *parm_err /* [out] [ref] */); /************************************************************//** * * NetFileClose * * @brief Close a file * * @param[in] server_name The server name to connect to * @param[in] fileid The fileid of the file that is going to be closed * @return NET_API_STATUS * * example file/file_close.c ***************************************************************/ NET_API_STATUS NetFileClose(const char * server_name /* [in] */, uint32_t fileid /* [in] */); /************************************************************//** * * NetFileGetInfo * * @brief Close a file * * @param[in] server_name The server name to connect to * @param[in] fileid The fileid of the file that is going to be closed * @param[in] level The level of the FILE_INFO_X buffer * @param[out] buffer The buffer containing a FILE_INFO_X structure * @return NET_API_STATUS * * example file/file_getinfo.c ***************************************************************/ NET_API_STATUS NetFileGetInfo(const char * server_name /* [in] */, uint32_t fileid /* [in] */, uint32_t level /* [in] */, uint8_t **buffer /* [out] [ref] */); /************************************************************//** * * NetFileEnum * * @brief Enumerate Files * * @param[in] server_name The server name to connect to * @param[in] base_path The * @param[in] user_name The * @param[in] level The level defining the FILE_INFO_X structure * @param[out] buffer The buffer containing a FILE_INFO_X structure * @param[in] prefmaxlen The requested maximal buffer size * @param[out] entries_read The number of FILE_INFO_X entries in the buffer * @param[out] total_entries The total number of FILE_INFO_X entries * @param[in,out] resume_handle A handle passed in and returned for resuming * operations * @return NET_API_STATUS * * example file/file_enum.c ***************************************************************/ NET_API_STATUS NetFileEnum(const char * server_name /* [in] */, const char * base_path /* [in] */, const char * user_name /* [in] */, uint32_t level /* [in] */, uint8_t **buffer /* [out] [ref] */, uint32_t prefmaxlen /* [in] */, uint32_t *entries_read /* [out] [ref] */, uint32_t *total_entries /* [out] [ref] */, uint32_t *resume_handle /* [in,out] [ref] */); #ifdef __cplusplus } #endif /* __cplusplus */ #endif /* __LIB_NETAPI_H__ */ ? ++match_lvl : 0; entry->direction == ref->direction ? ++match_lvl : 0; entry->sg_call_ents == ref->sg_call_ents ? ++match_lvl : 0; if (match_lvl == 4) { /* perfect-fit - return the result */ return entry; } else if (match_lvl > last_lvl) { /* * We found an entry that fits better then the * previous one */ last_lvl = match_lvl; ret = entry; } } /* * If we have multiple matches but no perfect-fit, just return * NULL. */ ret = (matches == 1) ? ret : NULL; return ret; } /* * Add an entry to a hash bucket */ static void hash_bucket_add(struct hash_bucket *bucket, struct dma_debug_entry *entry) { list_add_tail(&entry->list, &bucket->list); } /* * Remove entry from a hash bucket list */ static void hash_bucket_del(struct dma_debug_entry *entry) { list_del(&entry->list); } /* * Dump mapping entries for debugging purposes */ void debug_dma_dump_mappings(struct device *dev) { int idx; for (idx = 0; idx < HASH_SIZE; idx++) { struct hash_bucket *bucket = &dma_entry_hash[idx]; struct dma_debug_entry *entry; unsigned long flags; spin_lock_irqsave(&bucket->lock, flags); list_for_each_entry(entry, &bucket->list, list) { if (!dev || dev == entry->dev) { dev_info(entry->dev, "%s idx %d P=%Lx D=%Lx L=%Lx %s\n", type2name[entry->type], idx, (unsigned long long)entry->paddr, entry->dev_addr, entry->size, dir2name[entry->direction]); } } spin_unlock_irqrestore(&bucket->lock, flags); } } EXPORT_SYMBOL(debug_dma_dump_mappings); /* * Wrapper function for adding an entry to the hash. * This function takes care of locking itself. */ static void add_dma_entry(struct dma_debug_entry *entry) { struct hash_bucket *bucket; unsigned long flags; bucket = get_hash_bucket(entry, &flags); hash_bucket_add(bucket, entry); put_hash_bucket(bucket, &flags); } static struct dma_debug_entry *__dma_entry_alloc(void) { struct dma_debug_entry *entry; entry = list_entry(free_entries.next, struct dma_debug_entry, list); list_del(&entry->list); memset(entry, 0, sizeof(*entry)); num_free_entries -= 1; if (num_free_entries < min_free_entries) min_free_entries = num_free_entries; return entry; } /* struct dma_entry allocator * * The next two functions implement the allocator for * struct dma_debug_entries. */ static struct dma_debug_entry *dma_entry_alloc(void) { struct dma_debug_entry *entry = NULL; unsigned long flags; spin_lock_irqsave(&free_entries_lock, flags); if (list_empty(&free_entries)) { pr_err("DMA-API: debugging out of memory - disabling\n"); global_disable = true; goto out; } entry = __dma_entry_alloc(); #ifdef CONFIG_STACKTRACE entry->stacktrace.max_entries = DMA_DEBUG_STACKTRACE_ENTRIES; entry->stacktrace.entries = entry->st_entries; entry->stacktrace.skip = 2; save_stack_trace(&entry->stacktrace); #endif out: spin_unlock_irqrestore(&free_entries_lock, flags); return entry; } static void dma_entry_free(struct dma_debug_entry *entry) { unsigned long flags; /* * add to beginning of the list - this way the entries are * more likely cache hot when they are reallocated. */ spin_lock_irqsave(&free_entries_lock, flags); list_add(&entry->list, &free_entries); num_free_entries += 1; spin_unlock_irqrestore(&free_entries_lock, flags); } int dma_debug_resize_entries(u32 num_entries) { int i, delta, ret = 0; unsigned long flags; struct dma_debug_entry *entry; LIST_HEAD(tmp); spin_lock_irqsave(&free_entries_lock, flags); if (nr_total_entries < num_entries) { delta = num_entries - nr_total_entries; spin_unlock_irqrestore(&free_entries_lock, flags); for (i = 0; i < delta; i++) { entry = kzalloc(sizeof(*entry), GFP_KERNEL); if (!entry) break; list_add_tail(&entry->list, &tmp); } spin_lock_irqsave(&free_entries_lock, flags); list_splice(&tmp, &free_entries); nr_total_entries += i; num_free_entries += i; } else { delta = nr_total_entries - num_entries; for (i = 0; i < delta && !list_empty(&free_entries); i++) { entry = __dma_entry_alloc(); kfree(entry); } nr_total_entries -= i; } if (nr_total_entries != num_entries) ret = 1; spin_unlock_irqrestore(&free_entries_lock, flags); return ret; } EXPORT_SYMBOL(dma_debug_resize_entries); /* * DMA-API debugging init code * * The init code does two things: * 1. Initialize core data structures * 2. Preallocate a given number of dma_debug_entry structs */ static int prealloc_memory(u32 num_entries) { struct dma_debug_entry *entry, *next_entry; int i; for (i = 0; i < num_entries; ++i) { entry = kzalloc(sizeof(*entry), GFP_KERNEL); if (!entry) goto out_err; list_add_tail(&entry->list, &free_entries); } num_free_entries = num_entries; min_free_entries = num_entries; pr_info("DMA-API: preallocated %d debug entries\n", num_entries); return 0; out_err: list_for_each_entry_safe(entry, next_entry, &free_entries, list) { list_del(&entry->list); kfree(entry); } return -ENOMEM; } static ssize_t filter_read(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) { char buf[NAME_MAX_LEN + 1]; unsigned long flags; int len; if (!current_driver_name[0]) return 0; /* * We can't copy to userspace directly because current_driver_name can * only be read under the driver_name_lock with irqs disabled. So * create a temporary copy first. */ read_lock_irqsave(&driver_name_lock, flags); len = scnprintf(buf, NAME_MAX_LEN + 1, "%s\n", current_driver_name); read_unlock_irqrestore(&driver_name_lock, flags); return simple_read_from_buffer(user_buf, count, ppos, buf, len); } static ssize_t filter_write(struct file *file, const char __user *userbuf, size_t count, loff_t *ppos) { char buf[NAME_MAX_LEN]; unsigned long flags; size_t len; int i; /* * We can't copy from userspace directly. Access to * current_driver_name is protected with a write_lock with irqs * disabled. Since copy_from_user can fault and may sleep we * need to copy to temporary buffer first */ len = min(count, (size_t)(NAME_MAX_LEN - 1)); if (copy_from_user(buf, userbuf, len)) return -EFAULT; buf[len] = 0; write_lock_irqsave(&driver_name_lock, flags); /* * Now handle the string we got from userspace very carefully. * The rules are: * - only use the first token we got * - token delimiter is everything looking like a space * character (' ', '\n', '\t' ...) * */ if (!isalnum(buf[0])) { /* * If the first character userspace gave us is not * alphanumerical then assume the filter should be * switched off. */ if (current_driver_name[0]) pr_info("DMA-API: switching off dma-debug driver filter\n"); current_driver_name[0] = 0; current_driver = NULL; goto out_unlock; } /* * Now parse out the first token and use it as the name for the * driver to filter for. */ for (i = 0; i < NAME_MAX_LEN; ++i) { current_driver_name[i] = buf[i]; if (isspace(buf[i]) || buf[i] == ' ' || buf[i] == 0) break; } current_driver_name[i] = 0; current_driver = NULL; pr_info("DMA-API: enable driver filter for driver [%s]\n", current_driver_name); out_unlock: write_unlock_irqrestore(&driver_name_lock, flags); return count; } const struct file_operations filter_fops = { .read = filter_read, .write = filter_write, }; static int dma_debug_fs_init(void) { dma_debug_dent = debugfs_create_dir("dma-api", NULL); if (!dma_debug_dent) { pr_err("DMA-API: can not create debugfs directory\n"); return -ENOMEM; } global_disable_dent = debugfs_create_bool("disabled", 0444, dma_debug_dent, (u32 *)&global_disable); if (!global_disable_dent) goto out_err; error_count_dent = debugfs_create_u32("error_count", 0444, dma_debug_dent, &error_count); if (!error_count_dent) goto out_err; show_all_errors_dent = debugfs_create_u32("all_errors", 0644, dma_debug_dent, &show_all_errors); if (!show_all_errors_dent) goto out_err; show_num_errors_dent = debugfs_create_u32("num_errors", 0644, dma_debug_dent, &show_num_errors); if (!show_num_errors_dent) goto out_err; num_free_entries_dent = debugfs_create_u32("num_free_entries", 0444, dma_debug_dent, &num_free_entries); if (!num_free_entries_dent) goto out_err; min_free_entries_dent = debugfs_create_u32("min_free_entries", 0444, dma_debug_dent, &min_free_entries); if (!min_free_entries_dent) goto out_err; filter_dent = debugfs_create_file("driver_filter", 0644, dma_debug_dent, NULL, &filter_fops); if (!filter_dent) goto out_err; return 0; out_err: debugfs_remove_recursive(dma_debug_dent); return -ENOMEM; } static int device_dma_allocations(struct device *dev) { struct dma_debug_entry *entry; unsigned long flags; int count = 0, i; local_irq_save(flags); for (i = 0; i < HASH_SIZE; ++i) { spin_lock(&dma_entry_hash[i].lock); list_for_each_entry(entry, &dma_entry_hash[i].list, list) { if (entry->dev == dev) count += 1; } spin_unlock(&dma_entry_hash[i].lock); } local_irq_restore(flags); return count; } static int dma_debug_device_change(struct notifier_block *nb, unsigned long action, void *data) { struct device *dev = data; int count; switch (action) { case BUS_NOTIFY_UNBOUND_DRIVER: count = device_dma_allocations(dev); if (count == 0) break; err_printk(dev, NULL, "DMA-API: device driver has pending " "DMA allocations while released from device " "[count=%d]\n", count); break; default: break; } return 0; } void dma_debug_add_bus(struct bus_type *bus) { struct notifier_block *nb; nb = kzalloc(sizeof(struct notifier_block), GFP_KERNEL); if (nb == NULL) { pr_err("dma_debug_add_bus: out of memory\n"); return; } nb->notifier_call = dma_debug_device_change; bus_register_notifier(bus, nb); } /* * Let the architectures decide how many entries should be preallocated. */ void dma_debug_init(u32 num_entries) { int i; if (global_disable) return; for (i = 0; i < HASH_SIZE; ++i) { INIT_LIST_HEAD(&dma_entry_hash[i].list); spin_lock_init(&dma_entry_hash[i].lock); } if (dma_debug_fs_init() != 0) { pr_err("DMA-API: error creating debugfs entries - disabling\n"); global_disable = true; return; } if (req_entries) num_entries = req_entries; if (prealloc_memory(num_entries) != 0) { pr_err("DMA-API: debugging out of memory error - disabled\n"); global_disable = true; return; } nr_total_entries = num_free_entries; pr_info("DMA-API: debugging enabled by kernel config\n"); } static __init int dma_debug_cmdline(char *str) { if (!str) return -EINVAL; if (strncmp(str, "off", 3) == 0) { pr_info("DMA-API: debugging disabled on kernel command line\n"); global_disable = true; } return 0; } static __init int dma_debug_entries_cmdline(char *str) { int res; if (!str) return -EINVAL; res = get_option(&str, &req_entries); if (!res) req_entries = 0; return 0; } __setup("dma_debug=", dma_debug_cmdline); __setup("dma_debug_entries=", dma_debug_entries_cmdline); static void check_unmap(struct dma_debug_entry *ref) { struct dma_debug_entry *entry; struct hash_bucket *bucket; unsigned long flags; if (dma_mapping_error(ref->dev, ref->dev_addr)) { err_printk(ref->dev, NULL, "DMA-API: device driver tries " "to free an invalid DMA memory address\n"); return; } bucket = get_hash_bucket(ref, &flags); entry = hash_bucket_find(bucket, ref); if (!entry) { err_printk(ref->dev, NULL, "DMA-API: device driver tries " "to free DMA memory it has not allocated " "[device address=0x%016llx] [size=%llu bytes]\n", ref->dev_addr, ref->size); goto out; } if (ref->size != entry->size) { err_printk(ref->dev, entry, "DMA-API: device driver frees " "DMA memory with different size " "[device address=0x%016llx] [map size=%llu bytes] " "[unmap size=%llu bytes]\n", ref->dev_addr, entry->size, ref->size); } if (ref->type != entry->type) { err_printk(ref->dev, entry, "DMA-API: device driver frees " "DMA memory with wrong function " "[device address=0x%016llx] [size=%llu bytes] " "[mapped as %s] [unmapped as %s]\n", ref->dev_addr, ref->size, type2name[entry->type], type2name[ref->type]); } else if ((entry->type == dma_debug_coherent) && (ref->paddr != entry->paddr)) { err_printk(ref->dev, entry, "DMA-API: device driver frees " "DMA memory with different CPU address " "[device address=0x%016llx] [size=%llu bytes] " "[cpu alloc address=0x%016llx] " "[cpu free address=0x%016llx]", ref->dev_addr, ref->size, (unsigned long long)entry->paddr, (unsigned long long)ref->paddr); } if (ref->sg_call_ents && ref->type == dma_debug_sg && ref->sg_call_ents != entry->sg_call_ents) { err_printk(ref->dev, entry, "DMA-API: device driver frees " "DMA sg list with different entry count " "[map count=%d] [unmap count=%d]\n", entry->sg_call_ents, ref->sg_call_ents); } /* * This may be no bug in reality - but most implementations of the * DMA API don't handle this properly, so check for it here */ if (ref->direction != entry->direction) { err_printk(ref->dev, entry, "DMA-API: device driver frees " "DMA memory with different direction " "[device address=0x%016llx] [size=%llu bytes] " "[mapped with %s] [unmapped with %s]\n", ref->dev_addr, ref->size, dir2name[entry->direction], dir2name[ref->direction]); } hash_bucket_del(entry); dma_entry_free(entry); out: put_hash_bucket(bucket, &flags); } static void check_for_stack(struct device *dev, void *addr) { if (object_is_on_stack(addr)) err_printk(dev, NULL, "DMA-API: device driver maps memory from" "stack [addr=%p]\n", addr); } static inline bool overlap(void *addr, unsigned long len, void *start, void *end) { unsigned long a1 = (unsigned long)addr; unsigned long b1 = a1 + len; unsigned long a2 = (unsigned long)start; unsigned long b2 = (unsigned long)end; return !(b1 <= a2 || a1 >= b2); } static void check_for_illegal_area(struct device *dev, void *addr, unsigned long len) { if (overlap(addr, len, _text, _etext) || overlap(addr, len, __start_rodata, __end_rodata)) err_printk(dev, NULL, "DMA-API: device driver maps memory from kernel text or rodata [addr=%p] [len=%lu]\n", addr, len); } static void check_sync(struct device *dev, struct dma_debug_entry *ref, bool to_cpu) { struct dma_debug_entry *entry; struct hash_bucket *bucket; unsigned long flags; bucket = get_hash_bucket(ref, &flags); entry = hash_bucket_find(bucket, ref); if (!entry) { err_printk(dev, NULL, "DMA-API: device driver tries " "to sync DMA memory it has not allocated " "[device address=0x%016llx] [size=%llu bytes]\n", (unsigned long long)ref->dev_addr, ref->size); goto out; } if (ref->size > entry->size) { err_printk(dev, entry, "DMA-API: device driver syncs" " DMA memory outside allocated range " "[device address=0x%016llx] " "[allocation size=%llu bytes] " "[sync offset+size=%llu]\n", entry->dev_addr, entry->size, ref->size); } if (ref->direction != entry->direction) { err_printk(dev, entry, "DMA-API: device driver syncs " "DMA memory with different direction " "[device address=0x%016llx] [size=%llu bytes] " "[mapped with %s] [synced with %s]\n", (unsigned long long)ref->dev_addr, entry->size, dir2name[entry->direction], dir2name[ref->direction]); } if (entry->direction == DMA_BIDIRECTIONAL) goto out; if (to_cpu && !(entry->direction == DMA_FROM_DEVICE) && !(ref->direction == DMA_TO_DEVICE)) err_printk(dev, entry, "DMA-API: device driver syncs " "device read-only DMA memory for cpu " "[device address=0x%016llx] [size=%llu bytes] " "[mapped with %s] [synced with %s]\n", (unsigned long long)ref->dev_addr, entry->size, dir2name[entry->direction], dir2name[ref->direction]); if (!to_cpu && !(entry->direction == DMA_TO_DEVICE) && !(ref->direction == DMA_FROM_DEVICE)) err_printk(dev, entry, "DMA-API: device driver syncs " "device write-only DMA memory to device " "[device address=0x%016llx] [size=%llu bytes] " "[mapped with %s] [synced with %s]\n", (unsigned long long)ref->dev_addr, entry->size, dir2name[entry->direction], dir2name[ref->direction]); out: put_hash_bucket(bucket, &flags); } void debug_dma_map_page(struct device *dev, struct page *page, size_t offset, size_t size, int direction, dma_addr_t dma_addr, bool map_single) { struct dma_debug_entry *entry; if (unlikely(global_disable)) return; if (unlikely(dma_mapping_error(dev, dma_addr))) return; entry = dma_entry_alloc(); if (!entry) return; entry->dev = dev; entry->type = dma_debug_page; entry->paddr = page_to_phys(page) + offset; entry->dev_addr = dma_addr; entry->size = size; entry->direction = direction; if (map_single) entry->type = dma_debug_single; if (!PageHighMem(page)) { void *addr = page_address(page) + offset; check_for_stack(dev, addr); check_for_illegal_area(dev, addr, size); } add_dma_entry(entry); } EXPORT_SYMBOL(debug_dma_map_page); void debug_dma_unmap_page(struct device *dev, dma_addr_t addr, size_t size, int direction, bool map_single) { struct dma_debug_entry ref = { .type = dma_debug_page, .dev = dev, .dev_addr = addr, .size = size, .direction = direction, }; if (unlikely(global_disable)) return; if (map_single) ref.type = dma_debug_single; check_unmap(&ref); } EXPORT_SYMBOL(debug_dma_unmap_page); void debug_dma_map_sg(struct device *dev, struct scatterlist *sg, int nents, int mapped_ents, int direction) { struct dma_debug_entry *entry; struct scatterlist *s; int i; if (unlikely(global_disable)) return; for_each_sg(sg, s, mapped_ents, i) { entry = dma_entry_alloc(); if (!entry) return; entry->type = dma_debug_sg; entry->dev = dev; entry->paddr = sg_phys(s); entry->size = sg_dma_len(s); entry->dev_addr = sg_dma_address(s); entry->direction = direction; entry->sg_call_ents = nents; entry->sg_mapped_ents = mapped_ents; if (!PageHighMem(sg_page(s))) { check_for_stack(dev, sg_virt(s)); check_for_illegal_area(dev, sg_virt(s), sg_dma_len(s)); } add_dma_entry(entry); } } EXPORT_SYMBOL(debug_dma_map_sg); static int get_nr_mapped_entries(struct device *dev, struct dma_debug_entry *ref) { struct dma_debug_entry *entry; struct hash_bucket *bucket; unsigned long flags; int mapped_ents; bucket = get_hash_bucket(ref, &flags); entry = hash_bucket_find(bucket, ref); mapped_ents = 0; if (entry) mapped_ents = entry->sg_mapped_ents; put_hash_bucket(bucket, &flags); return mapped_ents; } void debug_dma_unmap_sg(struct device *dev, struct scatterlist *sglist, int nelems, int dir) { struct scatterlist *s; int mapped_ents = 0, i; if (unlikely(global_disable)) return; for_each_sg(sglist, s, nelems, i) { struct dma_debug_entry ref = { .type = dma_debug_sg, .dev = dev, .paddr = sg_phys(s), .dev_addr = sg_dma_address(s), .size = sg_dma_len(s), .direction = dir, .sg_call_ents = nelems, }; if (mapped_ents && i >= mapped_ents) break; if (!i) mapped_ents = get_nr_mapped_entries(dev, &ref); check_unmap(&ref); } } EXPORT_SYMBOL(debug_dma_unmap_sg); void debug_dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t dma_addr, void *virt) { struct dma_debug_entry *entry; if (unlikely(global_disable)) return; if (unlikely(virt == NULL)) return; entry = dma_entry_alloc(); if (!entry) return; entry->type = dma_debug_coherent; entry->dev = dev; entry->paddr = virt_to_phys(virt); entry->size = size; entry->dev_addr = dma_addr; entry->direction = DMA_BIDIRECTIONAL; add_dma_entry(entry); } EXPORT_SYMBOL(debug_dma_alloc_coherent); void debug_dma_free_coherent(struct device *dev, size_t size, void *virt, dma_addr_t addr) { struct dma_debug_entry ref = { .type = dma_debug_coherent, .dev = dev, .paddr = virt_to_phys(virt), .dev_addr = addr, .size = size, .direction = DMA_BIDIRECTIONAL, }; if (unlikely(global_disable)) return; check_unmap(&ref); } EXPORT_SYMBOL(debug_dma_free_coherent); void debug_dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size, int direction) { struct dma_debug_entry ref; if (unlikely(global_disable)) return; ref.type = dma_debug_single; ref.dev = dev; ref.dev_addr = dma_handle; ref.size = size; ref.direction = direction; ref.sg_call_ents = 0; check_sync(dev, &ref, true); } EXPORT_SYMBOL(debug_dma_sync_single_for_cpu); void debug_dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size, int direction) { struct dma_debug_entry ref; if (unlikely(global_disable)) return; ref.type = dma_debug_single; ref.dev = dev; ref.dev_addr = dma_handle; ref.size = size; ref.direction = direction; ref.sg_call_ents = 0; check_sync(dev, &ref, false); } EXPORT_SYMBOL(debug_dma_sync_single_for_device); void debug_dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle, unsigned long offset, size_t size, int direction) { struct dma_debug_entry ref; if (unlikely(global_disable)) return; ref.type = dma_debug_single; ref.dev = dev; ref.dev_addr = dma_handle; ref.size = offset + size; ref.direction = direction; ref.sg_call_ents = 0; check_sync(dev, &ref, true); } EXPORT_SYMBOL(debug_dma_sync_single_range_for_cpu); void debug_dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle, unsigned long offset, size_t size, int direction) { struct dma_debug_entry ref; if (unlikely(global_disable)) return; ref.type = dma_debug_single; ref.dev = dev; ref.dev_addr = dma_handle; ref.size = offset + size; ref.direction = direction; ref.sg_call_ents = 0; check_sync(dev, &ref, false); } EXPORT_SYMBOL(debug_dma_sync_single_range_for_device); void debug_dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems, int direction) { struct scatterlist *s; int mapped_ents = 0, i; if (unlikely(global_disable)) return; for_each_sg(sg, s, nelems, i) { struct dma_debug_entry ref = { .type = dma_debug_sg, .dev = dev, .paddr = sg_phys(s), .dev_addr = sg_dma_address(s), .size = sg_dma_len(s), .direction = direction, .sg_call_ents = nelems, }; if (!i) mapped_ents = get_nr_mapped_entries(dev, &ref); if (i >= mapped_ents) break; check_sync(dev, &ref, true); } } EXPORT_SYMBOL(debug_dma_sync_sg_for_cpu); void debug_dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems, int direction) { struct scatterlist *s; int mapped_ents = 0, i; if (unlikely(global_disable)) return; for_each_sg(sg, s, nelems, i) { struct dma_debug_entry ref = { .type = dma_debug_sg, .dev = dev, .paddr = sg_phys(s), .dev_addr = sg_dma_address(s), .size = sg_dma_len(s), .direction = direction, .sg_call_ents = nelems, }; if (!i)