~vcs-imports/samba/main

return undef unless $string =~ /([0-9,a-z]{8})-([0-9,a-z]{4})-([0-9,a-z]{4})-([0-9,a-z]{2})([0-9,a-z]{2})-([0-9,a-z]{2})([0-9,a-z]{2})([0-9,a-z]{2})([0-9,a-z]{2})([0-9,a-z]{2})([0-9,a-z]{2})/i;

1021

1022

return pack("I", hex $1) .

1023

pack("S", hex $2) .

1024

pack("S", hex $3) .

1025

pack("C", hex $4) .

1026

pack("C", hex $5) .

1027

pack("C", hex $6) .

1028

pack("C", hex $7) .

1029

pack("C", hex $8) .

1030

pack("C", hex $9) .

1031

pack("C", hex $10) .

1032

pack("C", hex $11);

1033

1034

# print "$1\n$2\n$3\n$4\n$5\n$6\n$7\n$8\n$9\n$10\n$11\n";

1035

}

1036

1037

sub bindstring_to_guid {

1038

my $str = shift;

1039

return pack("H2 H2 H2 H2 H2 H2 H2 H2 H2 H2 H2 H2 H2 H2 H2 H2",

1040

substr($str,0,2),

1041

substr($str,2,2),

1042

substr($str,4,2),

1043

substr($str,6,2),

1044

substr($str,8,2),

1045

substr($str,10,2),

1046

substr($str,12,2),

1047

substr($str,14,2),

1048

substr($str,16,2),

1049

substr($str,18,2),

1050

substr($str,20,2),

1051

substr($str,22,2),

1052

substr($str,24,2),

1053

substr($str,26,2),

1054

substr($str,28,2),

1055

substr($str,30,2));

1056

}

1057

1058

sub guid_to_string {

1059

my $guid = shift;

1060

my $string = sprintf "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",

1061

unpack("I", $guid),

1062

unpack("S", substr($guid, 4, 2)),

1063

unpack("S", substr($guid, 6, 2)),

1064

unpack("C", substr($guid, 8, 1)),

1065

unpack("C", substr($guid, 9, 1)),

1066

unpack("C", substr($guid, 10, 1)),

1067

unpack("C", substr($guid, 11, 1)),

1068

unpack("C", substr($guid, 12, 1)),

1069

unpack("C", substr($guid, 13, 1)),

1070

unpack("C", substr($guid, 14, 1)),

1071

unpack("C", substr($guid, 15, 1));

1072

return lc($string);

1073

}

1074

1075

sub guid_to_bindstring {

1076

my $guid = shift;

1077

return unpack("H" . 2 * length($guid), $guid),

1078

}

1079

1080

sub dump_wknguid {

1081

print "Dumping Well known GUIDs:\n";

1082

foreach my $wknguid (keys %wknguids) {

1083

1084

my $guid = bindstring_to_guid($wknguids{$wknguid});

1085

my $str = guid_to_string($guid);

1086

my $back = guid_to_bindstring($guid);

1087

1088

printf "wkguid: %s\n", $wknguid;

1089

printf "bind_string format: %s\n", $wknguids{$wknguid};

1090

printf "string format: %s\n", guid_to_string($guid);

1091

printf "back to bind_string:%s\n", guid_to_bindstring($guid);

1092

1093

printf "use base: \"<WKGUID=%s,%s>\"\n", guid_to_bindstring($guid), $base;

1094

}

1095

}

1096

1097

sub gen_bitmask_string_format($%) {

1098

my $mod = shift;

1099

my (%tmp) = @_;

1100

my @list;

1101

foreach my $key (sort keys %tmp) {

1102

push(@list, sprintf("%s %s", $tmp{$key}, $key));

1103

}

1104

return join("\n$mod$tabsize",@list);

1105

}

1106

1107

1108

sub nt_to_unixtime ($) {

1109

# the number of 100 nanosecond intervals since jan. 1. 1601 (utc)

1110

my $t64 = shift;

1111

$t64 =~ s/(.+).{7,7}/$1/;

1112

$t64 -= 11644473600;

1113

return $t64;

1114

}

1115

1116

sub dump_equal {

1117

my $val = shift;

1118

my $mod = shift || die "no mod";

1119

my (%header) = @_;

1120

my %tmp;

1121

my $found = 0;

1122

foreach my $key (keys %header) {

1123

if ($header{$key} eq $val) {

1124

$tmp{"($val)"} = $key;

1125

$found = 1;

1126

last;

1127

}

1128

}

1129

if (!$found) { $tmp{$val} = ""; };

1130

return gen_bitmask_string_format($mod,%tmp);

1131

}

1132

1133

sub dump_bitmask {

1134

my $op = shift || die "no op";

1135

my $val = shift;

1136

my $mod = shift || die "no mod";

1137

my (%header) = @_;

1138

my %tmp;

1139

$tmp{""} = $val;

1140

foreach my $key (sort keys %header) { # sort by val !

1141

if ($op eq "&") {

1142

$tmp{$key} = ( $val & $header{$key} ) ? $set:$unset;

1143

} elsif ($op eq "==") {

1144

$tmp{$key} = ( $val == $header{$key} ) ? $set:$unset;

1145

} else {

1146

print "unknown operator: $op\n";

1147

return;

1148

}

1149

}

1150

return gen_bitmask_string_format($mod,%tmp);

1151

}

1152

1153

sub dump_bitmask_and {

1154

return dump_bitmask("&",@_);

1155

}

1156

1157

sub dump_bitmask_equal {

1158

return dump_bitmask("==",@_);

1159

}

1160

1161

sub dump_uac {

1162

return dump_bitmask_and(@_,%ads_uf); # ads_uf ?

1163

}

1164

1165

sub dump_uascompat {

1166

return dump_bitmask_equal(@_,%ads_uascompat);

1167

}

1168

1169

sub dump_gpoptions {

1170

return dump_bitmask_equal(@_,%ads_gpoptions);

1171

}

1172

1173

sub dump_gpflags {

1174

return dump_bitmask_equal(@_,%ads_gpflags);

1175

}

1176

1177

sub dump_uacc {

1178

return dump_bitmask_equal(@_,%ads_uacc);

1179

}

1180

1181

sub dump_uf {

1182

return dump_bitmask_and(@_,%ads_uf);

1183

}

1184

1185

sub dump_gtype {

1186

my $ret = dump_bitmask_and(@_,%ads_grouptype);

1187

$ret .= "\n$tabsize\t";

1188

$ret .= dump_bitmask_equal(@_,%ads_gtype);

1189

return $ret;

1190

}

1191

1192

sub dump_atype {

1193

return dump_bitmask_equal(@_,%ads_atype);

1194

}

1195

1196

sub dump_controls {

1197

return dump_equal(@_,%ads_controls);

1198

}

1199

1200

sub dump_capabilities {

1201

return dump_equal(@_,%ads_capabilities);

1202

}

1203

1204

sub dump_extension {

1205

return dump_equal(@_,%ads_extensions);

1206

}

1207

1208

sub dump_systemflags {

1209

return dump_bitmask_and(@_,%ads_systemflags);

1210

}

1211

1212

sub dump_instance_type {

1213

return dump_bitmask_and(@_,%ads_instance_type);

1214

}

1215

1216

sub dump_ds_func {

1217

return dump_bitmask_equal(@_,%ads_ds_func);

1218

}

1219

1220

sub dump_serverstate {

1221

return dump_bitmask_equal(@_,%ads_serverstate);

1222

}

1223

1224

sub dump_sdeffective {

1225

return dump_bitmask_and(@_,%ads_sdeffective);

1226

}

1227

1228

sub dump_trustattr {

1229

return dump_bitmask_equal(@_,%ads_trustattrs);

1230

}

1231

1232

sub dump_trusttype {

1233

return dump_bitmask_equal(@_,%ads_trusttype);

1234

}

1235

1236

sub dump_trustdirection {

1237

return dump_bitmask_equal(@_,%ads_trustdirection);

1238

}

1239

1240

sub dump_pwdproperties {

1241

return dump_bitmask_and(@_,%ads_pwdproperties);

1242

}

1243

1244

sub dump_frstype {

1245

return dump_bitmask_equal(@_,%ads_frstypes)

1246

}

1247

1248

sub dump_mixed_domain {

1249

return dump_bitmask_equal(@_,%ads_mixed_domain);

1250

}

1251

1252

sub dump_sid {

1253

my $bin_sid = shift;

1254

return sid2string($bin_sid);

1255

}

1256

1257

sub dump_guid {

1258

my $guid = shift;

1259

return guid_to_string($guid);

1260

}

1261

1262

sub dump_secdesc {

1263

my $val = shift;

1264

return "FIXME: write sddl-converter!";

1265

}

1266

1267

sub dump_nttime {

1268

my $nttime = shift;

1269

if ($nttime == 0) {

1270

return sprintf("%s (%s)", "never", $nttime);

1271

}

1272

my $localtime = localtime(nt_to_unixtime($nttime));

1273

return sprintf("%s (%s)", $localtime, $nttime);

1274

}

1275

1276

sub dump_nttime_abs {

1277

if ($_[0] == 9223372036854775807) {

1278

return sprintf("%s (%s)", "now", $_[0]);

1279

}

1280

if ($_[0] == -9223372036854775808 || $_[0] == 0) { # 0x7FFFFFFFFFFFFFFF

1281

return sprintf("%s (%s)", "never", $_[0]);

1282

}

1283

# FIXME: actually *do* abs time !

1284

return dump_nttime($_[0]);

1285

}

1286

1287

sub dump_timestr {

1288

my $time = shift;

1289

if ($time eq "16010101000010.0Z") {

1290

return sprintf("%s (%s)", "never", $time);

1291

}

1292

my ($year,$mon,$mday,$hour,$min,$sec,$zone) =

1293

unpack('a4 a2 a2 a2 a2 a2 a4', $time);

1294

$mon -= 1;

1295

my $localtime = localtime(timegm($sec,$min,$hour,$mday,$mon,$year));

1296

return sprintf("%s (%s)", $localtime, $time);

1297

}

1298

1299

sub dump_string {

1300

return $_[0];

1301

}

1302

1303

sub dump_int {

1304

return sprintf("%d", $_[0]);

1305

}

1306

1307

sub dump_munged_dial {

1308

my $dial = shift;

1309

return "FIXME! decode this";

1310

}

1311

1312

sub dump_cert {

1313

1314

my $cert = shift;

1315

open(OPENSSL, "| /usr/bin/openssl x509 -text -inform der");

1316

print OPENSSL $cert;

1317

close(OPENSSL);

1318

return "";

1319

}

1320

1321

sub dump_pkt {

1322

my $pkt = shift;

1323

return "not yet";

1324

printf("%s: ", $pkt);

1325

printf("%02X", $pkt);

1326

1327

}

1328

1329

sub dump_gplink {

1330

1331

my $gplink = shift;

1332

my $gplink_mod = $gplink;

1333

my @links = split("\\]\\[", $gplink_mod);

1334

foreach my $link (@links) {

1335

$link =~ s/^\[|\]$//g;

1336

my ($ldap_link, $opt) = split(";", $link);

1337

my @array = ( "$opt", "\t" );

1338

printf("%slink: %s, opt: %s\n", $tabsize, $ldap_link, dump_bitmask_and(@array, %ads_gplink_opts));

1339

}

1340

return $gplink;

1341

}

1342

1343

sub construct_filter {

1344

1345

my $tmp = shift;

1346

1347

if (!$tmp || $opt_notify) {

1348

return "(objectclass=*)";

1349

}

1350

1351

if ($tmp && $tmp !~ /^.*\=/) {

1352

return "(ANR=$tmp)";

1353

}

1354

1355

return $tmp;

1356

# (&(objectCategory=person)

1357

# (userAccountControl:$ads_matching_rules{LDAP_MATCHING_RULE_BIT_AND}:=2))

1358

}

1359

1360

sub construct_attrs {

1361

1362

my @attrs = @_;

1363

1364

if (!@attrs) {

1365

push(@attrs,"*");

1366

}

1367

1368

if ($opt_notify) {

1369

push(@attrs,"uSNChanged");

1370

}

1371

1372

if ($opt_display_metadata) {

1373

push(@attrs,"msDS-ReplAttributeMetaData");

1374

push(@attrs,"replPropertyMetaData");

1375

}

1376

1377

if ($opt_verbose) {

1378

push(@attrs,"nTSecurityDescriptor");

1379

push(@attrs,"msDS-KeyVersionNumber");

1380

push(@attrs,"msDS-User-Account-Control-Computed");

1381

push(@attrs,"modifyTimeStamp");

1382

}

1383

1384

return sort @attrs;

1385

}

1386

1387

sub print_header {

1388

1389

print "\n";

1390

printf "%10s: %s\n", "uri", $uri;

1391

printf "%10s: %s\n", "port", $port;

1392

printf "%10s: %s\n", "base", $base;

1393

printf "%10s: %s\n", $sasl_bind ? "principal" : "binddn", $sasl_bind ? $upn : $binddn;

1394

printf "%10s: %s\n", "password", $password;

1395

printf "%10s: %s\n", "bind-type", $sasl_bind ? "SASL" : "simple";

1396

printf "%10s: %s\n", "sasl-mech", $sasl_mech if ($sasl_mech);

1397

printf "%10s: %s\n", "filter", $filter;

1398

printf "%10s: %s\n", "scope", $scope;

1399

printf "%10s: %s\n", "attrs", join(", ", @attrs);

1400

printf "%10s: %s\n", "controls", join(", ", @ctrls_s);

1401

printf "%10s: %s\n", "page_size", $opt_paging if ($opt_paging);

1402

printf "%10s: %s\n", "start_tls", $opt_starttls ? "yes" : "no";

1403

printf "\n";

1404

}

1405

1406

sub gen_controls {

1407

1408

# setup attribute-scoped query control

1409

my $asq_asn = Convert::ASN1->new;

1410

$asq_asn->prepare(

1411

q< asq ::= SEQUENCE {

1412

sourceAttribute OCTET_STRING

1413

}

1414

1415

);

1416

my $ctl_asq_val = $asq_asn->encode( sourceAttribute => $opt_asq);

1417

my $ctl_asq = Net::LDAP::Control->new(

1418

type => $ads_controls{'LDAP_SERVER_ASQ_OID'},

1419

critical => 'true',

1420

value => $ctl_asq_val);

1421

1422

1423

# setup extended dn control

1424

my $asn_extended_dn = Convert::ASN1->new;

1425

$asn_extended_dn->prepare(

1426

q< ExtendedDn ::= SEQUENCE {

1427

mode INTEGER

1428

}

1429

1430

);

1431

1432

# only w2k3 accepts '1' and needs the ctl_val, w2k does not accept a ctl_val

1433

my $ctl_extended_dn_val = $asn_extended_dn->encode( mode => $opt_display_extendeddn);

1434

my $ctl_extended_dn = Net::LDAP::Control->new(

1435

type => $ads_controls{'LDAP_SERVER_EXTENDED_DN_OID'},

1436

critical => 'true',

1437

value => $opt_display_extendeddn ? $ctl_extended_dn_val : "");

1438

1439

# setup notify control

1440

my $ctl_notification = Net::LDAP::Control->new(

1441

type => $ads_controls{'LDAP_SERVER_NOTIFICATION_OID'},

1442

critical => 'true');

1443

1444

1445

# setup paging control

1446

$ctl_paged = Net::LDAP::Control->new(

1447

type => $ads_controls{'LDAP_PAGED_RESULT_OID_STRING'},

1448

critical => 'true',

1449

size => $opt_paging ? $opt_paging : 1000);

1450

1451

# setup domscope control

1452

my $ctl_domscope = Net::LDAP::Control->new(

1453

type => $ads_controls{'LDAP_SERVER_DOMAIN_SCOPE_OID'},

1454

critical => 'true',

1455

value => "");

1456

1457

if (defined($opt_paging)) {

1458

push(@ctrls, $ctl_paged);

1459

push(@ctrls_s, "LDAP_PAGED_RESULT_OID_STRING" );

1460

}

1461

1462

if (defined($opt_display_extendeddn)) {

1463

push(@ctrls, $ctl_extended_dn);

1464

push(@ctrls_s, "LDAP_SERVER_EXTENDED_DN_OID");

1465

}

1466

if ($opt_notify) {

1467

push(@ctrls, $ctl_notification);

1468

push(@ctrls_s, "LDAP_SERVER_NOTIFICATION_OID");

1469

}

1470

1471

if ($opt_asq) {

1472

push(@ctrls, $ctl_asq);

1473

push(@ctrls_s, "LDAP_SERVER_ASQ_OID");

1474

}

1475

1476

if ($opt_domain_scope) {

1477

push(@ctrls, $ctl_domscope);

1478

push(@ctrls_s, "LDAP_SERVER_DOMAIN_SCOPE_OID");

1479

}

1480

1481

return @ctrls;

1482

}

1483

1484

sub display_value_generic ($$$) {

1485

1486

my ($mod,$attr,$value) = @_;

1487

return unless (defined($value) and defined($attr));

1488

1489

if ( ! $opt_display_raw && exists $attr_handler{$attr} ) {

1490

$value = $attr_handler{$attr}($value,$mod);

1491

write_ads_list($mod,$attr,$value);

1492

return;

1493

}

1494

write_ads($mod,$attr,$value);

1495

}

1496

1497

sub display_attr_generic ($$$) {

1498

1499

my ($mod,$entry,$attr) = @_;

1500

return if (!$attr || !$entry);

1501

1502

my $ref = $entry->get_value($attr, asref => 1);

1503

my @values = @$ref;

1504

1505

foreach my $value ( sort @values) {

1506

display_value_generic($mod,$attr,$value);

1507

}

1508

}

1509

1510

sub display_entry_generic ($) {

1511

1512

my $entry = shift;

1513

return if (!$entry);

1514

1515

foreach my $attr ( sort $entry->attributes) {

1516

display_attr_generic("\t",$entry,$attr);

1517

}

1518

}

1519

1520

sub display_ldap_err ($) {

1521

1522

my $msg = shift;

1523

print_header();

1524

my ($package, $filename, $line, $subroutine) = caller(0);

1525

1526

print "got error from ADS:\n";

1527

printf("%s(%d): ERROR (%s): %s\n",

1528

$subroutine, $line, $msg->code, $msg->error);

1529

1530

}

1531

1532

sub process_result {

1533

1534

my ($msg,$entry) = @_;

1535

1536

if (!defined($msg)) {

1537

return;

1538

}

1539

1540

if ($msg->code) {

1541

display_ldap_err($msg);

1542

exit 1;

1543

}

1544

1545

if (!defined($entry)) {

1546

return;

1547

}

1548

1549

if ($entry->isa('Net::LDAP::Reference')) {

1550

foreach my $ref ($entry->references) {

1551

print "\ngot Reference: [$ref]\n";

1552

}

1553

return;

1554

}

1555

1556

print "\nfound entry: ".$entry->dn."\n".("-" x 80)."\n";

1557

1558

display_entry_generic($entry);

1559

}

1560

1561

sub default_callback {

1562

1563

my ($res,$obj) = @_;

1564

1565

if ($res->code == LDAP_REFERRAL) {

1566

return;

1567

}

1568

1569

if (!$opt_notify) {

1570

return process_result($res,$obj);

1571

}

1572

}

1573

1574

sub error_callback {

1575

1576

my ($msg,$entry) = @_;

1577

1578

if (!$msg) {

1579

return;

1580

}

1581

1582

if ($msg->code) {

1583

display_ldap_err($msg);

1584

exit(1);

1585

}

1586

return;

1587

}

1588

1589

sub notify_callback {

1590

1591

my ($msg, $obj) = @_;

1592

1593

if (! defined($obj)) {

1594

return;

1595

}

1596

1597

if ($obj->isa('Net::LDAP::Reference')) {

1598

foreach my $ref ($obj->references) {

1599

print "\ngot Reference: [$ref]\n";

1600

}

1601

return;

1602

}

1603

1604

while (1) {

1605

1606

my $async_entry = $async_search->pop_entry;

1607

1608

if (!$async_entry->dn) {

1609

print "very weird. entry has no dn\n";

1610

next;

1611

}

1612

1613

printf("\ngot changenotify for dn: [%s]\n%s\n", $async_entry->dn, ("-" x 80));

1614

1615

my $new_usn = $async_entry->get_value('uSNChanged');

1616

if (!$new_usn) {

1617

die "odd, no usnChanged attribute???";

1618

}

1619

if (!$usn || $new_usn > $usn) {

1620

$usn = $new_usn;

1621

if ($opt_notify_nodiffs) {

1622

display_entry_generic($async_entry);

1623

} else {

1624

display_result_diff($async_entry);

1625

}

1626

}

1627

store_result($async_entry);

1628

}

1629

}

1630

1631

sub do_bind($$) {

1632

1633

my $async_ldap_hd = shift || return undef;

1634

my $sasl_bind = shift;

1635

1636

if ($sasl_bind) {

1637

if (!$works_sasl) {

1638

print "this version of Net::LDAP does not have proper SASL support.\n";

1639

print "Need at least perl-ldap V. $pref_version\n";

1640

}

1641

$sasl_hd = get_sasl_hd();

1642

if (!$sasl_hd) {

1643

print "failed to create SASL handle\n";

1644

return -1;

1645

}

1646

$mesg = $async_ldap_hd->bind(

1647

sasl => $sasl_hd,

1648

callback => \&error_callback

1649

) || die "doesnt work";

1650

} else {

1651

$sasl_mech = "";

1652

$mesg = $async_ldap_hd->bind(

1653

$binddn,

1654

password => $password,

1655

callback => $opt_fastbind ? undef : \&error_callback

1656

) || die "doesnt work";

1657

};

1658

if ($mesg->code) {

1659

display_ldap_err($mesg) if (!$opt_fastbind);

1660

return -1;

1661

}

1662

return 0;

1663

}

1664

1665

sub do_fast_bind() {

1666

1667

do_unbind();

1668

1669

my $hd = get_ldap_hd($server,1);

1670

1671

my $mesg = $hd->extension(

1672

name => $ads_extensions{'LDAP_SERVER_FAST_BIND_OID'});

1673

1674

if ($mesg->code) {

1675

display_ldap_err($mesg);

1676

return -1;

1677

}

1678

1679

my $ret = do_bind($hd, undef);

1680

$hd->unbind;

1681

1682

printf("bind using 'LDAP_SERVER_FAST_BIND_OID' %s\n",

1683

$ret == 0 ? "succeeded" : "failed");

1684

1685

return $ret;

1686

}

1687

1688

sub do_unbind() {

1689

if ($async_ldap_hd) {

1690

$async_ldap_hd->unbind;

1691

}

1692

if ($sync_ldap_hd) {

1693

$sync_ldap_hd->unbind;

1694

}

1695

}

1696

1697

###############################################################################

1698

1699

sub main () {

1700

1701

if ($opt_fastbind) {

1702

1703

if (check_exts($server,$dse,"LDAP_SERVER_FAST_BIND_OID") == -1) {

1704

print "LDAP_SERVER_FAST_BIND_OID not supported by this server\n";

1705

exit 1;

1706

}

1707

1708

# fast bind can only bind, not search

1709

exit do_fast_bind();

1710

}

1711

1712

$filter = construct_filter($query);

1713

@attrs = construct_attrs(@attrs);

1714

@ctrls = gen_controls();

1715

1716

if (check_ctrls($server,$dse,@ctrls) == -1) {

1717

print "not all required LDAP Controls are supported by this server\n";

1718

exit 1;

1719

}

1720

1721

if ($opt_dump_rootdse) {

1722

print "Dumping Root-DSE:\n";

1723

display_entry_generic($dse);

1724

exit 0;

1725

}

1726

1727

if ($opt_dump_wknguid) {

1728

dump_wknguid();

1729

exit 0;

1730

}

1731

1732

if (do_bind($async_ldap_hd, $sasl_bind) == -1) {

1733

exit 1;

1734

}

1735

1736

print_header();

1737

1738

if ($opt_dump_schema) {

1739

print "Dumping Schema:\n";

1740

my $ads_schema = $async_ldap_hd->schema;

1741

$ads_schema->dump;

1742

exit 0;

1743

}

1744

1745

while (1) {

1746

1747

$async_search = $async_ldap_hd->search(

1748

base => $base,

1749

filter => $filter,

1750

attrs => [ @attrs ],

1751

control => [ @ctrls ],

1752

callback => \&default_callback,

1753

scope => $scope,

1754

) || die "cannot search";

1755

1756

if ($async_search->code == LDAP_REFERRAL) {

1757

foreach my $ref ($async_search->referrals) {

1758

print "\ngot Referral: [$ref]\n";

1759

$async_ldap_hd->unbind();

1760

$async_ldap_hd = get_ldap_hd($ref, 1);

1761

if (do_bind($async_ldap_hd, $sasl_bind) == -1) {

1762

$async_ldap_hd->unbind();

1763

next;

1764

}

1765

print "\nsuccessful rebind to: [$ref]\n";

1766

last;

1767

}

1768

next; # repeat the query

1769

}

1770

1771

if ($opt_notify) {

1772

1773

print "Base [$base] is registered now for change-notify\n";

1774

print "\nWaiting for change-notify...\n";

1775

1776

my $sync_ldap_hd = get_ldap_hd($server,0);

1777

if (do_bind($sync_ldap_hd, $sasl_bind) == -1) {

1778

exit 2;

1779

}

1780

1781

my $sync_search = $sync_ldap_hd->search(

1782

base => $base,

1783

filter => $filter,

1784

attrs => [ @attrs ],

1785

callback => \&notify_callback,

1786

scope => $scope,

1787

) || die "cannot search";

1788

1789

}

1790

1791

$total_entry_count += $async_search->count;

1792

++$page_count;

1793

print "-" x 80 . "\n";

1794

printf("Got %d Entries in Page %d \n\n",

1795

$async_search->count, $page_count);

1796

my ($resp) = $async_search->control(

1797

$ads_controls{'LDAP_PAGED_RESULT_OID_STRING'} ) or last;

1798

last unless ref $resp && $ctl_paged->cookie($resp->cookie);

1799

}

1800

1801

if ($async_search->entries == 0) {

1802

print "No entries found with filter $filter\n";

1803

} else {

1804

print "Got $total_entry_count Entries in $page_count Pages\n" if ($opt_paging);

1805

}

1806

1807

do_unbind()

1808

}

1809

1810

main();

1811

1812

exit 0;

Older »