Home Backend Development C#.Net Tutorial Implementing RMI to break through firewall based on Servlet

Implementing RMI to break through firewall based on Servlet

Dec 20, 2016 pm 04:30 PM
Socket firewall

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

package com.mypack.web.rmi;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.EOFException;

import java.io.IOException;

import java.io.OutputStream;

import java.io.PrintWriter;

import java.net.InetAddress;

import java.net.Socket;

import java.net.URL;

import java.net.UnknownHostException;

import java.rmi.Naming;

import java.rmi.RMISecurityManager;

import java.rmi.RemoteException;

import java.rmi.registry.LocateRegistry;

import java.rmi.server.RMIClassLoader;

import java.rmi.server.UnicastRemoteObject;

import java.util.Hashtable;

import javax.servlet.ServletConfig;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

/**

 * The default RMI socket factory contains several "fallback" mechanisms which

 * enable an RMI client to communicate with a remote server. When an RMI client

 * initiates contact with a remote server, it attempts to establish a connection

 * using each of the following protocols in turn, until one succeeds:

 *

 * 1. Direct TCP connection. 2. Direct HTTP connection. 3. Proxy connection

 * (SOCKS or HTTP). 4. Connection on port 80 over HTTP to a CGI script. 5. Proxy

 * HTTP connection to CGI script on port 80.

 *

 * The RMI ServletHandler can be used as replacement for the java-rmi.cgi script

 * that comes with the Java Development Kit (and is invoked in protocols 4 and 5

 * above). The java-rmi.cgi script and the ServletHandler both function as proxy

 * applications that forward remote calls embedded in HTTP to local RMI servers

 * which service these calls. The RMI ServletHandler enables RMI to tunnel

 * remote method calls over HTTP more efficiently than the existing java-rmi.cgi

 * script. The ServletHandler is only loaded once from the servlet

 * administration utility. The script, java-rmi.cgi, is executed once every

 * remote call.

 *

 * The ServletHandler class contains methods for executing as a Java servlet

 * extension. Because the RMI protocol only makes use of the HTTP post command,

 * the ServletHandler only supports the <code>doPost</code>

 * <code>HttpServlet</code> method. The <code>doPost</code> method of this class

 * interprets a servlet request&#39;s query string as a command of the form

 * "<command>=<parameters>". These commands are represented by the abstract

 * interface, <code>RMICommandHandler</code>. Once the <code>doPost</code>

 * method has parsed the requested command, it calls the execute method on one

 * of several command handlers in the <code>commands</code> array.

 *

 * The command that actually proxies remote calls is the

 * <code>ServletForwardCommand</code>. When the execute method is invoked on the

 * ServletForwardCommand, the command will open a connection on a local port

 * specified by its <code>param</code> parameter and will proceed to write the

 * body of the relevant post request into this connection. It is assumed that an

 * RMI server (e.g. SampleRMIServer) is listening on the local port, "param."

 * The "forward" command will then read the RMI server&#39;s response and send this

 * information back to the RMI client as the body of the response to the HTTP

 * post method.

 *

 * Because the ServletHandler uses a local socket to proxy remote calls, the

 * servlet has the ability to forward remote calls to local RMI objects that

 * reside in the ServletVM or outside of it.

 *

 * Servlet documentation may be found at the following location:

 *

 * http://jserv.javasoft.com/products/java-server/documentation/

 * webserver1.0.2/apidoc/Package-javax.servlet.http.html

 */

public class ServletHandler extends HttpServlet implements Runnable {

/* Variables to hold optional configuration properties. */

/**

* serialVersionUID

*/

private static final long serialVersionUID = 1L;

/** codebase from which this servlet will load remote objects. */

protected static String initialServerCodebase = null;

/** name of RMI server class to be created in init method */

protected static String initialServerClass = null;

/** name of RMI server class to be created in init method */

protected static String initialServerBindName = null;

/**

* RMICommandHandler is the abstraction for an object that handles a

* particular supported command (for example the "forward" command

* "forwards" call information to a remote server on the local machine).

*

* The command handler is only used by the ServletHandler so the interface

* is protected.

*/

protected interface RMICommandHandler {

/**

* Return the string form of the command to be recognized in the query

* string.

*/

public String getName();

/**

* Execute the command with the given string as parameter.

*/

public void execute(HttpServletRequest req, HttpServletResponse res,

String param) throws ServletClientException,

ServletServerException, IOException;

}

/**

* List of handlers for supported commands. A new command will be created

* for every service request

*/

private static RMICommandHandler commands[] = new RMICommandHandler[] {

new ServletForwardCommand(), new ServletGethostnameCommand(),

new ServletPingCommand(), new ServletTryHostnameCommand() };

/* construct table mapping command strings to handlers */

private static Hashtable commandLookup;

static {

commandLookup = new Hashtable();

for (int i = 0; i < commands.length; ++i)

commandLookup.put(commands[i].getName(), commands[i]);

}

/**

* Once loaded, Java Servlets continue to run until they are unloaded or the

* webserver is stopped. This example takes advantage of the extended

* Servlet life-cycle and runs a remote object in the Servlet VM.

*

* To initialize this remote object the Servlet Administrator should specify

* a set of parameters which will be used to download and install an initial

* remote server (see readme.txt).

*

* If configuration parameters are valid (not blank), the servlet will

* attempt to load and start a remote object and a registry in which the

* object may be bound.

*

* @param config

*            Standard configuration object for an http servlet.

*

* @exception ServletException

*                Calling <code>super.init(config)</code> may cause a

*                servlet exception to be thrown.

*/

public void init(ServletConfig config) throws ServletException {

super.init(config);

try {

setConfigParameters(config);

if (!verifyConfigParameters()) {

// dont export any objects.

System.err.println("Some optional parameters not set, "

+ "remote object not exported; "

+ "ServletHandler is runnning.");

return;

}

/*

* RMI requires that a local security manager be responsible for the

* method invocations from remote clients - we need to make sure a

* security manager is installed.

*/

if (System.getSecurityManager() == null) {

System.setSecurityManager(new RMISecurityManager());

}

// create a registry if one is not running already.

try {

LocateRegistry.createRegistry(1099);

} catch (java.rmi.server.ExportException ee) {

// registry already exists, we&#39;ll just use it.

} catch (RemoteException re) {

System.err.println(re.getMessage());

re.printStackTrace();

}

/**

* Download and create a server object in a thread so we do not

* interfere with other servlets. Allow init method to return more

* quickly.

*/

(new Thread(this)).start();

System.out.println("RMI Servlet Handler loaded sucessfully.");

} catch (Exception e) {

System.err.println("Exception thrown in RMI ServletHandler: "

+ e.getMessage());

e.printStackTrace();

}

}

/**

* Create the sample RMI server.

*/

public void run() {

try {

UnicastRemoteObject server = createRemoteObjectUsingDownloadedClass();

if (server != null) {

Naming.rebind(initialServerBindName, server);

System.err.println("Remote object created successfully.");

}

} catch (Exception e) {

System.err.println("Exception received while intalling object:");

System.err.println(e.getMessage());

e.printStackTrace();

}

}

/**

* Load and export an initial remote object. The implementation class for

* this remote object should not be loaded from the servlet&#39;s class path;

* instead it should be loaded from a URL location that will be accessible

* from a remote client. In the case of this example, that location will be

* <code>initialServerCodebase</code>

*/

UnicastRemoteObject createRemoteObjectUsingDownloadedClass()

throws Exception {

UnicastRemoteObject server = null;

Class serverClass = null;

int MAX_RETRY = 5;

int retry = 0;

int sleep = 2000;

while ((retry < MAX_RETRY) && (serverClass == null)) {

try {

System.err.println("Attempting to load remote class...");

serverClass = RMIClassLoader.loadClass(new URL(

initialServerCodebase), initialServerClass);

// Before we instantiate the obj. make sure it

// is a UnicastRemoteObject.

if (!Class.forName("java.rmi.server.UnicastRemoteObject")

.isAssignableFrom(serverClass)) {

System.err.println("This example requires an "

+ " instance of UnicastRemoteObject,"

+ " remote object not exported.");

} else {

System.out.println("Server class loaded successfully...");

server = ((UnicastRemoteObject) serverClass.newInstance());

}

} catch (java.lang.ClassNotFoundException cnfe) {

retry++;

/**

* The class for the remote object could not be loaded, perhaps

* the webserver has not finished initializing itself yet. Try

* to load the class a few more times...

*/

if (retry >= MAX_RETRY) {

System.err.println("Failed to load remote server "

+ " class. Remote object not " + " exported... ");

} else {

System.err.println("Could not load remote class, "

+ "trying again...");

try {

Thread.sleep(sleep);

} catch (InterruptedException ie) {

}

continue;

}

}

}

return server;

}

/*

* NOTE: If you are using JDK1.2Beta4 or later, it is recommended that you

* provide your servlet with a destroy method that will unexport any remote

* objects that your servlet ever exports. As mentioned in the readme file

* for this example, it is not possible to unexport remote objects in

* JDK1.1.x; there is no method in the RMI 1.1 public API that will perform

* this task. To restart remote objects in the servlet VM, you will have to

* restart your webserver. In JDK1.2x, the methods to unexport a remote

* object are as follows:

*

* java.rmi.activation.Activatable. unexportObject(Remote obj, boolean

* force) java.rmi.server.UnicastRemoteObject. unexportObject(Remote obj,

* boolean force)

*/

/**

* Execute the command given in the servlet request query string. The string

* before the first &#39;=&#39; in the queryString is interpreted as the command

* name, and the string after the first &#39;=&#39; is the parameters to the

* command.

*

* @param req

*            HTTP servlet request, contains incoming command and arguments

* @param res

*            HTTP servlet response

* @exception ServletException

*                and IOException when invoking methods of

*                <code>req<code> or <code>res<code>.

*/

public void doPost(HttpServletRequest req, HttpServletResponse res)

throws ServletException, IOException {

try {

// Command and parameter for this POST request.

String queryString = req.getQueryString();

String command, param;

int delim = queryString.indexOf("=");

if (delim == -1) {

command = queryString;

param = "";

} else {

command = queryString.substring(0, delim);

param = queryString.substring(delim + 1);

}

System.out.println("command: " + command);

System.out.println("param: " + param);

// lookup command to execute on the client&#39;s behalf

RMICommandHandler handler = (RMICommandHandler) commandLookup

.get(command);

// execute the command

if (handler != null)

try {

handler.execute(req, res, param);

} catch (ServletClientException e) {

returnClientError(res, "client error: " + e.getMessage());

e.printStackTrace();

} catch (ServletServerException e) {

returnServerError(res, "internal server error: "

+ e.getMessage());

e.printStackTrace();

}

else

returnClientError(res, "invalid command: " + command);

} catch (Exception e) {

returnServerError(res, "internal error: " + e.getMessage());

e.printStackTrace();

}

}

/**

* Provide more intelligible errors for methods that are likely to be

* called. Let unsupported HTTP "do*" methods result in an error generated

* by the super class.

*

* @param req

*            http Servlet request, contains incoming command and arguments

*

* @param res

*            http Servlet response

*

* @exception ServletException

*                and IOException when invoking methods of

*                <code>req<code> or <code>res<code>.

*/

public void doGet(HttpServletRequest req, HttpServletResponse res)

throws ServletException, IOException {

returnClientError(res, "GET Operation not supported: "

+ "Can only forward POST requests.");

}

public void doPut(HttpServletRequest req, HttpServletResponse res)

throws ServletException, IOException {

returnClientError(res, "PUT Operation not supported: "

+ "Can only forward POST requests.");

}

public String getServletInfo() {

return "RMI Call Forwarding Servlet Servlet.<br>\n";

}

/**

* Return an HTML error message indicating there was error in the client&#39;s

* request.

*

* @param res

*            Servlet response object through which <code>message</code>

*            will be written to the client which invoked one of this

*            servlet&#39;s methods.

* @param message

*            Error message to be written to client.

*/

private static void returnClientError(HttpServletResponse res,

String message) throws IOException {

res

.sendError(HttpServletResponse.SC_BAD_REQUEST, "<HTML><HEAD>"

+ "<TITLE>Java RMI Client Error</TITLE>" + "</HEAD>"

+ "<BODY>" + "<H1>Java RMI Client Error</H1>" + message

+ "</BODY></HTML>");

System.err.println(HttpServletResponse.SC_BAD_REQUEST

+ "Java RMI Client Error" + message);

}

/**

* Return an HTML error message indicating an internal error occurred here

* on the server.

*

* @param res

*            Servlet response object through which <code>message</code>

*            will be written to the servlet client.

* @param message

*            Error message to be written to servlet client.

*/

private static void returnServerError(HttpServletResponse res,

String message) throws IOException {

res.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,

"<HTML><HEAD>" + "<TITLE>Java RMI Server Error</TITLE>"

+ "</HEAD>" + "<BODY>"

+ "<H1>Java RMI Server Error</H1>" + message

+ "</BODY></HTML>");

System.err.println(HttpServletResponse.SC_INTERNAL_SERVER_ERROR

+ "Java RMI Server Error: " + message);

}

/**

* Retrieve parameters from servlet configuration object.

*

* @param config

*            Standard configuration object for an HTTP servlet.

*/

protected synchronized void setConfigParameters(ServletConfig config) {

try {

initialServerCodebase = config

.getInitParameter("rmiservlethandler.initialServerCodebase");

initialServerClass = config

.getInitParameter("rmiservlethandler.initialServerClass");

initialServerBindName = config

.getInitParameter("rmiservlethandler.initialServerBindName");

} catch (Exception e) {

System.err.println("");

System.err.println("Could not access init parameter:");

System.err.println(e.getMessage());

e.printStackTrace();

}

}

/**

* Ensure that servlet configuration parameters are valid.

*

* @return <code>true</code> if all relevant configuration parameters are

*         valid (i.e. not "") <code>false</code> otherwise.

*/

protected synchronized boolean verifyConfigParameters() {

return ((verifyParameter("rmiservlethandler.initialServerClass ",

initialServerClass))

&& (verifyParameter("rmiservlethandler.initialServerBindName ",

initialServerBindName)) && (verifyParameter(

"rmiservlethandler.initialServerCodebase",

initialServerCodebase)));

}

/**

* Verify that a single parameter is valid.

*

* @return <code>true</code> if the parameter is valid.

*/

protected boolean verifyParameter(String parameterName, String parameter) {

if ((parameter == null) || (parameter.equals(""))) {

System.err.println("optional parameter is invalid and "

+ "will not be used: \n    " + parameterName + " = "

+ parameter);

return false;

} else {

System.err.println(parameterName + " " + "valid: " + parameter);

}

return true;

}

/*

* The ServletHandler class is the only object that needs to access the

* CommandHandler subclasses, so we write the commands internal to the

* servlet handler.

*/

/**

* Class that has an execute command to forward request body to local port

* on the server and send server reponse back to client.

*/

protected static class ServletForwardCommand implements RMICommandHandler {

public String getName() {

return "forward";

}

/**

* Execute the forward command. Forwards data from incoming servlet

* request to a port on the local machine. Presumably, an RMI server

* will be reading the data that this method sends.

*

* @param req

*            The servlet request.

* @param res

*            The servlet response.

* @param param

*            Port to which data will be sent.

*/

public void execute(HttpServletRequest req, HttpServletResponse res,

String param) throws ServletClientException,

ServletServerException, IOException {

int port;

try {

port = Integer.parseInt(param);

} catch (NumberFormatException e) {

throw new ServletClientException("invalid port number: "

+ param);

}

if (port <= 0 || port > 0xFFFF)

throw new ServletClientException("invalid port: " + port);

if (port < 1024)

throw new ServletClientException("permission denied for port: "

+ port);

byte buffer[];

Socket socket;

try {

socket = new Socket(InetAddress.getLocalHost(), port);

} catch (IOException e) {

throw new ServletServerException("could not connect to "

+ "local port");

}

// read client&#39;s request body

DataInputStream clientIn = new DataInputStream(req.getInputStream());

buffer = new byte[req.getContentLength()];

try {

clientIn.readFully(buffer);

} catch (EOFException e) {

throw new ServletClientException("unexpected EOF "

+ "reading request body");

} catch (IOException e) {

throw new ServletClientException("error reading request"

+ " body");

}

DataOutputStream socketOut = null;

// send to local server in HTTP

try {

socketOut = new DataOutputStream(socket.getOutputStream());

socketOut.writeBytes("POST / HTTP/1.0\r\n");

socketOut.writeBytes("Content-length: "

+ req.getContentLength() + "\r\n\r\n");

socketOut.write(buffer);

socketOut.flush();

} catch (IOException e) {

throw new ServletServerException("error writing to server");

}

// read response from local server

DataInputStream socketIn;

try {

socketIn = new DataInputStream(socket.getInputStream());

} catch (IOException e) {

throw new ServletServerException("error reading from "

+ "server");

}

String key = "Content-length:".toLowerCase();

boolean contentLengthFound = false;

String line;

int responseContentLength = -1;

do {

try {

line = socketIn.readLine();

} catch (IOException e) {

throw new ServletServerException(

"error reading from server");

}

if (line == null)

throw new ServletServerException(

"unexpected EOF reading server response");

if (line.toLowerCase().startsWith(key)) {

if (contentLengthFound)

; // what would we want to do in this case??

responseContentLength = Integer.parseInt(line.substring(

key.length()).trim());

contentLengthFound = true;

}

} while ((line.length() != 0) && (line.charAt(0) != &#39;\r&#39;)

&& (line.charAt(0) != &#39;\n&#39;));

if (!contentLengthFound || responseContentLength < 0)

throw new ServletServerException(

"missing or invalid content length in server response");

buffer = new byte[responseContentLength];

try {

socketIn.readFully(buffer);

} catch (EOFException e) {

throw new ServletServerException(

"unexpected EOF reading server response");

} catch (IOException e) {

throw new ServletServerException("error reading from server");

}

// send local server response back to servlet client

res.setStatus(HttpServletResponse.SC_OK);

res.setContentType("application/octet-stream");

res.setContentLength(buffer.length);

try {

OutputStream out = res.getOutputStream();

out.write(buffer);

out.flush();

} catch (IOException e) {

throw new ServletServerException("error writing response");

} finally {

socketOut.close();

socketIn.close();

}

}

}

/**

* Class that has an execute method to return the host name of the server as

* the response body.

*/

protected static class ServletGethostnameCommand implements

RMICommandHandler {

public String getName() {

return "gethostname";

}

public void execute(HttpServletRequest req, HttpServletResponse res,

String param) throws ServletClientException,

ServletServerException, IOException {

byte[] getHostStringBytes = req.getServerName().getBytes();

res.setStatus(HttpServletResponse.SC_OK);

res.setContentType("application/octet-stream");

res.setContentLength(getHostStringBytes.length);

OutputStream out = res.getOutputStream();

out.write(getHostStringBytes);

out.flush();

}

}

/**

* Class that has an execute method to return an OK status to indicate that

* connection was successful.

*/

protected static class ServletPingCommand implements RMICommandHandler {

public String getName() {

return "ping";

}

public void execute(HttpServletRequest req, HttpServletResponse res,

String param) throws ServletClientException,

ServletServerException, IOException {

res.setStatus(HttpServletResponse.SC_OK);

res.setContentType("application/octet-stream");

res.setContentLength(0);

}

}

/**

* Class that has an execute method to return a human readable message

* describing which host name is available to local Java VMs.

*/

protected static class ServletTryHostnameCommand implements

RMICommandHandler {

public String getName() {

return "hostname";

}

public void execute(HttpServletRequest req, HttpServletResponse res,

String param) throws ServletClientException,

ServletServerException, IOException {

PrintWriter pw = res.getWriter();

pw.println("");

pw.println("<HTML>" + "<HEAD><TITLE>Java RMI Server Hostname Info"

+ "</TITLE></HEAD>" + "<BODY>");

pw.println("<H1>Java RMI Server Hostname Info</H1>");

pw.println("<H2>Local host name available to Java VM:</H2>");

pw.print("<P>InetAddress.getLocalHost().getHostName()");

try {

String localHostName = InetAddress.getLocalHost().getHostName();

pw.println(" = " + localHostName);

} catch (UnknownHostException e) {

pw.println(" threw java.net.UnknownHostException");

}

pw.println("<H2>Server host information obtained through Servlet "

+ "interface from HTTP server:</H2>");

pw.println("<P>SERVER_NAME = " + req.getServerName());

pw.println("<P>SERVER_PORT = " + req.getServerPort());

pw.println("</BODY></HTML>");

}

}

/**

* ServletClientException is thrown when an error is detected in a client&#39;s

* request.

*/

protected static class ServletClientException extends Exception {

public ServletClientException(String s) {

super(s);

}

}

/**

* ServletServerException is thrown when an error occurs here on the server.

*/

protected static class ServletServerException extends Exception {

public ServletServerException(String s) {

super(s);

}

}

}

Copy after login

Statement of this Website
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn

Hot AI Tools

Undresser.AI Undress

Undresser.AI Undress

AI-powered app for creating realistic nude photos

AI Clothes Remover

AI Clothes Remover

Online AI tool for removing clothes from photos.

Undress AI Tool

Undress AI Tool

Undress images for free

Clothoff.io

Clothoff.io

AI clothes remover

Video Face Swap

Video Face Swap

Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Tools

Notepad++7.3.1

Notepad++7.3.1

Easy-to-use and free code editor

SublimeText3 Chinese version

SublimeText3 Chinese version

Chinese version, very easy to use

Zend Studio 13.0.1

Zend Studio 13.0.1

Powerful PHP integrated development environment

Dreamweaver CS6

Dreamweaver CS6

Visual web development tools

SublimeText3 Mac version

SublimeText3 Mac version

God-level code editing software (SublimeText3)

Hot Topics

Java Tutorial
1662
14
PHP Tutorial
1261
29
C# Tutorial
1234
24
How to fix 'Error: 0x80070185, Cloud operation was unsuccessful” in OneDrive How to fix 'Error: 0x80070185, Cloud operation was unsuccessful” in OneDrive May 16, 2023 pm 04:26 PM

OneDrive is a popular cloud storage application provided by Microsoft. Most of us use OneDrive to store our files, folders, documents, etc. But some users complained that when they try to access shared files on OneDrive, it gives an error stating “Error: 0x80070185, Cloud operation was unsuccessful”. Therefore, they cannot perform any operations on OneDrive such as copying files, pasting, downloading shared files, etc. Nowadays, it is necessary to use these operations in our daily work. This error can be easily solved and for this we have some methods that we can apply and try to solve the problem. let's start! Method 1 – Sign out and sign back in to OneDrive app steps

8 Big Fixes if Grammarly Not Working on Windows 10 Browser 8 Big Fixes if Grammarly Not Working on Windows 10 Browser May 05, 2023 pm 02:16 PM

If you have syntax issues on your Windows 10 or 11 PC, this article will help you solve the problem. Grammarly is one of the most popular typing assistants for fixing grammar, spelling, clarity, and more. It has become an essential part of writing professionals. However, if it doesn't work properly, it can be a very frustrating experience. Many Windows users have reported that this tool does not work well on their computers. We did an in-depth analysis and found the cause and solution of this problem. Why doesn't Grammarly work on my PC? Grammarly on PC may not work properly due to several common reasons. It includes the following

Win11 firewall advanced settings gray solution Win11 firewall advanced settings gray solution Dec 24, 2023 pm 07:53 PM

When setting up the firewall, many friends found that their win11 firewall advanced settings were grayed out and unable to be clicked. This may be caused by not adding a control unit, or by not opening the advanced settings in the correct way. Let’s take a look at how to solve it. Win11 firewall advanced settings gray method one: 1. First, click the start menu below, search and open "Control Panel" at the top 2. Then open "Windows Defender Firewall" 3. After entering, you can open "Advanced Settings" in the left column . Method 2: 1. If the above method cannot be opened, you can right-click "Start Menu" and open "Run" 2. Then enter "mmc" and press Enter to confirm opening. 3. After opening, click on the upper left

How to Fix Steam Error Code 130 on Windows PC How to Fix Steam Error Code 130 on Windows PC Apr 28, 2023 pm 01:40 PM

Steam is a popular online game streaming platform that allows its users to purchase and play games as well as chat with other gamers on the platform. In addition to the features it offers, there are also some bugs encountered on the platform. One such error encountered by many Steam users is “Error code: 130 The webpage cannot be loaded (Unknown error)”. This error occurs when the Steam client attempts to load a web page but is unable to retrieve the page from its server. This error code may appear on any page in the Steam client, including inventory pages, update news, or store pages that prevent you from searching for a game you're interested in purchasing. One of the main reasons for this problem is a weak internet connection on your PC. Other possible causes are Stea

Fix: Windows 11 Firewall blocks printer Fix: Windows 11 Firewall blocks printer May 01, 2023 pm 08:28 PM

Firewalls monitor network traffic and can block network connections for certain programs and hardware. Windows 11 includes its own Windows Defender Firewall, which may block printers from accessing the web. Therefore, affected users cannot use their Brother printers when the firewall blocks it. Keep in mind that this issue affects other brands as well, but today we’ll show you how to fix it. Why is my Brother printer blocked by the firewall? There are several causes for this issue, and you will most likely need to open certain ports before your printer can access the network. Printer software can also cause problems, so be sure to update it as well as your printer driver. Read on to learn how

How to enable or disable firewall on Alpine Linux? How to enable or disable firewall on Alpine Linux? Feb 21, 2024 pm 12:45 PM

On AlpineLinux, you can use the iptables tool to configure and manage firewall rules. Here are the basic steps to enable or disable the firewall on AlpineLinux: Check the firewall status: sudoiptables -L If the output shows rules (for example, there are some INPUT, OUTPUT, or FORWARD rules), the firewall is enabled. If the output is empty, the firewall is currently disabled. Enable firewall: sudoiptables-PINPUTACCEPTsudoiptables-POUTPUTACCEPTsudoiptables-PFORWARDAC

Resolve error code 0xc004f074 when activating Windows 11. Resolve error code 0xc004f074 when activating Windows 11. May 08, 2023 pm 07:10 PM

After installing the latest operating system on your PC, activating your copy of Windows 11 is the main job. Not only does it unlock the true potential of the Windows 11 operating system, but it also gets rid of the annoying "Activate your Windows 11" message. However, for some users, Windows 11 activation error 0xc004f074 hinders the smooth progress of activation. This bug apparently prevents users from activating Windows 11 and forces them to use an operating system with limited functionality. Windows 11 activation error code 0xc004f074 is related to the Key Management Service. You will encounter this problem when KMS is unavailable. Okay, that's it for this tutorial

How to remove the firewall logo on the Win10 desktop icon? How to remove the firewall logo on the Win10 desktop icon? Jan 01, 2024 pm 12:21 PM

Many friends who use win10 system find that there is a firewall logo on the icon on the computer desktop. What is going on? This makes many friends with obsessive-compulsive disorder particularly uncomfortable. In fact, we only need to open the control panel and click " It can be solved by changing "Change User Account Control Settings". Let's take a look at the specific tutorial. How to cancel the firewall logo on the desktop icon in Windows 10 1. First, right-click the Start menu button next to the computer startup screen, and then select the Control Panel function from the pop-up menu. 2. Then select the "User Account" option and select the "Change User Account Control Settings" item from the new interface that appears. 3. After adjusting the slider in the window to the bottom, click Confirm to exit.

See all articles