1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package org.waarp.openr66.protocol.http.adminssl;
21
22 import io.netty.buffer.ByteBuf;
23 import io.netty.buffer.Unpooled;
24 import io.netty.channel.Channel;
25 import io.netty.channel.ChannelFuture;
26 import io.netty.channel.ChannelHandlerContext;
27 import io.netty.channel.SimpleChannelInboundHandler;
28 import io.netty.handler.codec.http.DefaultFullHttpResponse;
29 import io.netty.handler.codec.http.FullHttpRequest;
30 import io.netty.handler.codec.http.FullHttpResponse;
31 import io.netty.handler.codec.http.HttpHeaderNames;
32 import io.netty.handler.codec.http.HttpHeaderValues;
33 import io.netty.handler.codec.http.HttpMethod;
34 import io.netty.handler.codec.http.HttpResponse;
35 import io.netty.handler.codec.http.HttpResponseStatus;
36 import io.netty.handler.codec.http.HttpUtil;
37 import io.netty.handler.codec.http.HttpVersion;
38 import io.netty.handler.codec.http.QueryStringDecoder;
39 import io.netty.handler.codec.http.cookie.Cookie;
40 import io.netty.handler.codec.http.cookie.DefaultCookie;
41 import io.netty.handler.codec.http.cookie.ServerCookieDecoder;
42 import io.netty.handler.codec.http.cookie.ServerCookieEncoder;
43 import io.netty.handler.traffic.TrafficCounter;
44 import org.waarp.common.command.exception.Reply421Exception;
45 import org.waarp.common.command.exception.Reply530Exception;
46 import org.waarp.common.crypto.ssl.WaarpSslUtility;
47 import org.waarp.common.database.DbAdmin;
48 import org.waarp.common.database.DbPreparedStatement;
49 import org.waarp.common.database.DbSession;
50 import org.waarp.common.database.exception.WaarpDatabaseException;
51 import org.waarp.common.database.exception.WaarpDatabaseNoConnectionException;
52 import org.waarp.common.database.exception.WaarpDatabaseSqlException;
53 import org.waarp.common.digest.FilesystemBasedDigest;
54 import org.waarp.common.exception.FileTransferException;
55 import org.waarp.common.exception.InvalidArgumentException;
56 import org.waarp.common.file.DirInterface;
57 import org.waarp.common.logging.WaarpLogLevel;
58 import org.waarp.common.logging.WaarpLogger;
59 import org.waarp.common.logging.WaarpLoggerFactory;
60 import org.waarp.common.role.RoleDefault.ROLE;
61 import org.waarp.common.utility.ParametersChecker;
62 import org.waarp.common.utility.ThreadLocalRandom;
63 import org.waarp.common.utility.Version;
64 import org.waarp.common.utility.WaarpShutdownHook;
65 import org.waarp.common.utility.WaarpStringUtils;
66 import org.waarp.gateway.kernel.http.HttpWriteCacheEnable;
67 import org.waarp.openr66.client.Message;
68 import org.waarp.openr66.context.ErrorCode;
69 import org.waarp.openr66.context.R66FiniteDualStates;
70 import org.waarp.openr66.context.R66Result;
71 import org.waarp.openr66.context.R66Session;
72 import org.waarp.openr66.context.task.SpooledInformTask;
73 import org.waarp.openr66.database.DbConstantR66;
74 import org.waarp.openr66.database.data.DbHostAuth;
75 import org.waarp.openr66.database.data.DbHostConfiguration;
76 import org.waarp.openr66.database.data.DbRule;
77 import org.waarp.openr66.database.data.DbTaskRunner;
78 import org.waarp.openr66.protocol.configuration.Configuration;
79 import org.waarp.openr66.protocol.configuration.Messages;
80 import org.waarp.openr66.protocol.exception.OpenR66Exception;
81 import org.waarp.openr66.protocol.exception.OpenR66ExceptionTrappedFactory;
82 import org.waarp.openr66.protocol.exception.OpenR66ProtocolBusinessException;
83 import org.waarp.openr66.protocol.exception.OpenR66ProtocolBusinessNoWriteBackException;
84 import org.waarp.openr66.protocol.localhandler.LocalChannelReference;
85 import org.waarp.openr66.protocol.localhandler.LocalServerHandler;
86 import org.waarp.openr66.protocol.localhandler.ServerActions;
87 import org.waarp.openr66.protocol.localhandler.packet.ErrorPacket;
88 import org.waarp.openr66.protocol.localhandler.packet.RequestPacket;
89 import org.waarp.openr66.protocol.localhandler.packet.RequestPacket.TRANSFERMODE;
90 import org.waarp.openr66.protocol.localhandler.packet.TestPacket;
91 import org.waarp.openr66.protocol.networkhandler.NetworkTransaction;
92 import org.waarp.openr66.protocol.utils.ChannelUtils;
93 import org.waarp.openr66.protocol.utils.NbAndSpecialId;
94 import org.waarp.openr66.protocol.utils.R66Future;
95 import org.waarp.openr66.protocol.utils.TransferUtils;
96
97 import java.io.IOException;
98 import java.sql.Timestamp;
99 import java.util.Arrays;
100 import java.util.List;
101 import java.util.Locale;
102 import java.util.Map;
103 import java.util.Map.Entry;
104 import java.util.Set;
105 import java.util.concurrent.ConcurrentHashMap;
106
107
108
109
110 public class HttpSslHandler
111 extends SimpleChannelInboundHandler<FullHttpRequest> {
112 private static final String XXXLEVEL4XXX = "XXXLEVEL4XXX";
113 private static final String XXXLEVEL3XXX = "XXXLEVEL3XXX";
114 private static final String XXXLEVEL2XXX = "XXXLEVEL2XXX";
115 private static final String XXXLEVEL1XXX = "XXXLEVEL1XXX";
116 private static final String OPEN_R66_WEB_ERROR = "OpenR66 Web Error {}";
117 private static final String HTTP_SSL_HANDLER_MOPS = "HttpSslHandler.MOPS";
118 private static final String HTTP_SSL_HANDLER_LANG_IS =
119 "HttpSslHandler.LangIs";
120 private static final String HTTP_SSL_HANDLER_17 = "HttpSslHandler.17";
121 private static final String EXPORT_ERROR = "Export error: {}";
122 private static final String CHECKED = "checked";
123 private static final String HTTP_SSL_HANDLER_NOT_ACTIVE =
124 "HttpSslHandler.NotActive";
125 private static final String HTTP_SSL_HANDLER_ACTIVE = "HttpSslHandler.Active";
126 private static final String AN_ERROR_OCCURS_WHILE_ACCESSING_A_RUNNER =
127 "An error occurs while accessing a Runner: {}";
128 private static final String ADDRESS = "address";
129 private static final String CREATE = "Create";
130 private static final String ERROR2 = "error";
131 private static final String TRANSFER2 = "transfer";
132 private static final String PENDING2 = "pending";
133 private static final String START2 = "start";
134 private static final String STOPID2 = "stopid";
135 private static final String STARTID2 = "startid";
136 private static final String FILTER = "Filter";
137 private static final String ACTION = "ACTION";
138 private static final String HTTP_SSL_HANDLER_3 = "HttpSslHandler.3";
139 private static final String BR_B = "<br><b>";
140 private static final String B_CENTER_P = "</b></center></p>";
141
142
143
144 private static final WaarpLogger logger =
145 WaarpLoggerFactory.getLogger(HttpSslHandler.class);
146
147
148
149 protected static final ConcurrentHashMap<String, R66Session> sessions =
150 new ConcurrentHashMap<String, R66Session>();
151 protected static final ThreadLocalRandom RANDOM = ThreadLocalRandom.current();
152
153 protected R66Session authentHttp = new R66Session(false);
154
155 protected FullHttpRequest request;
156 protected boolean newSession;
157 protected Cookie admin;
158 protected final StringBuilder responseContent = new StringBuilder();
159 protected String uriRequest;
160 protected Map<String, List<String>> params;
161 protected String lang = Messages.getSlocale();
162 protected boolean forceClose;
163 protected boolean shutdown;
164
165 protected static final String R66SESSION = "R66SESSION";
166 protected static final String I18NEXT = "i18next";
167
168 private enum REQUEST {
169 Logon("Logon.html"), Logout("Logon.html"), index("index.html"),
170 error("error.html"), unallowed("NotAllowed.html"),
171 Transfers("Transfers.html"),
172 Listing("Listing_head.html", "Listing_body0.html", "Listing_body.html",
173 "Listing_body1.html", "Listing_end.html"),
174 CancelRestart("CancelRestart_head.html", "CancelRestart_body0.html",
175 "CancelRestart_body.html", "CancelRestart_body1.html",
176 "CancelRestart_end.html"), Export("Export.html"),
177 Hosts("Hosts_head.html", "Hosts_body0.html", "Hosts_body.html",
178 "Hosts_body1.html", "Hosts_end.html"),
179 Rules("Rules_head.html", "Rules_body0.html", "Rules_body.html",
180 "Rules_body1.html", "Rules_end.html"), System("System.html"),
181 SystemLimited("SystemLimited.html"), Spooled("Spooled.html"),
182 SpooledDetailed("Spooled.html");
183
184 private final String header;
185 private final String headerBody;
186 private final String body;
187 private final String endBody;
188 private final String end;
189
190
191
192
193
194
195 REQUEST(final String uniquefile) {
196 header = uniquefile;
197 headerBody = null;
198 body = null;
199 endBody = null;
200 end = null;
201 }
202
203
204
205
206
207
208
209
210 REQUEST(final String header, final String headerBody, final String body,
211 final String endBody, final String end) {
212 this.header = header;
213 this.headerBody = headerBody;
214 this.body = body;
215 this.endBody = endBody;
216 this.end = end;
217 }
218
219
220
221
222
223
224 public String readFileUnique(final HttpSslHandler handler) {
225 return handler.readFile(
226 Configuration.configuration.getHttpBasePath() + header);
227 }
228
229 public String readHeader(final HttpSslHandler handler) {
230 return handler.readFile(
231 Configuration.configuration.getHttpBasePath() + header);
232 }
233
234 public String readBodyHeader() {
235 return WaarpStringUtils.readFile(
236 Configuration.configuration.getHttpBasePath() + headerBody);
237 }
238
239 public String readBody() {
240 return WaarpStringUtils.readFile(
241 Configuration.configuration.getHttpBasePath() + body);
242 }
243
244 public String readBodyEnd() {
245 return WaarpStringUtils.readFile(
246 Configuration.configuration.getHttpBasePath() + endBody);
247 }
248
249 public String readEnd() {
250 return WaarpStringUtils.readFile(
251 Configuration.configuration.getHttpBasePath() + end);
252 }
253 }
254
255 protected enum REPLACEMENT {
256 XXXHOSTIDXXX, XXXADMINXXX, XXXVERSIONXXX, XXXBANDWIDTHXXX,
257 XXXBANDWIDTHINXXX, XXXBANDWIDTHOUTXXX, XXXXSESSIONLIMITRXXX,
258 XXXXSESSIONLIMITWXXX, XXXXCHANNELLIMITRXXX, XXXXCHANNELLIMITWXXX,
259 XXXXDELAYCOMMDXXX, XXXXDELAYRETRYXXX, XXXXDELATRAFFICXXX, XXXLOCALXXX,
260 XXXNETWORKXXX, XXXNBTRANSFERSXXX, XXXERRORMESGXXX, XXXXBUSINESSXXX,
261 XXXXROLESXXX, XXXXALIASESXXX, XXXXOTHERXXX, XXXLIMITROWXXX, XXXREFRESHXXX,
262 XXXLANGXXX, XXXCURLANGENXXX, XXXCURLANGFRXXX, XXXCURSYSLANGENXXX,
263 XXXCURSYSLANGFRXXX
264 }
265
266 public static final String sLIMITROW = "LIMITROW";
267 static final String XXXRESULTXXX = "XXXRESULTXXX";
268
269 private int limitRow = 48;
270
271 private int refresh;
272
273
274
275
276
277
278 DbSession dbSession;
279
280 public static String hashStatus() {
281 return "HttpSslHandler: [sessions: " + sessions.size() + "] ";
282 }
283
284 String readFile(final String filename) {
285 final String value;
286 try {
287 value = WaarpStringUtils.readFileException(filename);
288 } catch (final FileTransferException e) {
289 logger.error("Error while trying to read: " + filename, e);
290 return "";
291 }
292 final StringBuilder builder = new StringBuilder(value);
293 WaarpStringUtils.replace(builder, REPLACEMENT.XXXLOCALXXX.toString(),
294 Configuration.configuration.getLocalTransaction()
295 .getNumberLocalChannel() +
296 " Thread(" + Thread.activeCount() + ')');
297 WaarpStringUtils.replace(builder, REPLACEMENT.XXXNETWORKXXX.toString(),
298 Integer.toString(DbAdmin.getNbConnection() -
299 Configuration.getNbDbSession()));
300 WaarpStringUtils.replace(builder, REPLACEMENT.XXXNBTRANSFERSXXX.toString(),
301 Long.toString(
302 Configuration.configuration.getMonitoring().nbCountAllRunningStep));
303 WaarpStringUtils.replaceAll(builder, REPLACEMENT.XXXHOSTIDXXX.toString(),
304 Configuration.configuration.getHostId());
305 if (authentHttp.isAuthenticated()) {
306 WaarpStringUtils.replace(builder, REPLACEMENT.XXXADMINXXX.toString(),
307 Messages.getString(
308 "HttpSslHandler.1"));
309 } else {
310 WaarpStringUtils.replace(builder, REPLACEMENT.XXXADMINXXX.toString(),
311 Messages.getString(
312 "HttpSslHandler.0"));
313 }
314 final TrafficCounter trafficCounter =
315 Configuration.configuration.getGlobalTrafficShapingHandler()
316 .trafficCounter();
317 final long read = trafficCounter.lastReadThroughput();
318 final long write = trafficCounter.lastWriteThroughput();
319 WaarpStringUtils.replace(builder, REPLACEMENT.XXXBANDWIDTHXXX.toString(),
320 Messages.getString("HttpSslHandler.IN") +
321 (read >> 20) +
322 Messages.getString(HTTP_SSL_HANDLER_MOPS) +
323
324 Messages.getString("HttpSslHandler.OUT") +
325
326 (write >> 20) + Messages.getString(
327 HTTP_SSL_HANDLER_MOPS));
328 WaarpStringUtils.replace(builder, REPLACEMENT.XXXBANDWIDTHINXXX.toString(),
329 (read >> 20) + Messages.getString(
330 HTTP_SSL_HANDLER_MOPS));
331 WaarpStringUtils.replace(builder, REPLACEMENT.XXXBANDWIDTHOUTXXX.toString(),
332 (write >> 20) + Messages.getString(
333 HTTP_SSL_HANDLER_MOPS));
334 WaarpStringUtils.replaceAll(builder, REPLACEMENT.XXXLIMITROWXXX.toString(),
335 String.valueOf(getLimitRow()));
336 WaarpStringUtils.replaceAll(builder, REPLACEMENT.XXXREFRESHXXX.toString(),
337 String.valueOf(getRefresh() / 1000));
338 WaarpStringUtils.replaceAll(builder, REPLACEMENT.XXXLANGXXX.toString(),
339 lang);
340 return builder.toString();
341 }
342
343 protected final String getTrimValue(final String varname) {
344 final List<String> varlist = params.get(varname);
345 if (varlist != null && !varlist.isEmpty()) {
346 String value = params.get(varname).get(0).trim();
347 if (ParametersChecker.isEmpty(value)) {
348 value = null;
349 }
350 return value;
351 }
352 return null;
353 }
354
355 final String getValue(final String varname) {
356 return params.get(varname).get(0);
357 }
358
359 private String index() {
360 final String index = REQUEST.index.readFileUnique(this);
361 final StringBuilder builder = new StringBuilder(index);
362 WaarpStringUtils.replaceAll(builder, REPLACEMENT.XXXHOSTIDXXX.toString(),
363 Configuration.configuration.getHostId());
364 WaarpStringUtils.replaceAll(builder, REPLACEMENT.XXXADMINXXX.toString(),
365 Messages.getString(
366 "HttpSslHandler.2"));
367 WaarpStringUtils.replace(builder, REPLACEMENT.XXXVERSIONXXX.toString(),
368 Version.fullIdentifier());
369 return builder.toString();
370 }
371
372 protected String error(final String mesg) {
373 final String index = REQUEST.error.readFileUnique(this);
374 return index.replaceAll(REPLACEMENT.XXXERRORMESGXXX.toString(), mesg);
375 }
376
377 private String unallowed(final String mesg) {
378 final String index = REQUEST.unallowed.readFileUnique(this);
379 if (ParametersChecker.isEmpty(index)) {
380 return error(mesg);
381 }
382 return index.replaceAll(REPLACEMENT.XXXERRORMESGXXX.toString(), mesg);
383 }
384
385 protected String logon() {
386 return REQUEST.Logon.readFileUnique(this);
387 }
388
389 private String transfers() {
390 return REQUEST.Transfers.readFileUnique(this);
391 }
392
393 final String resetOptionTransfer(final String header, final String startid,
394 final String stopid, final String start,
395 final String stop, final String rule,
396 final String req, final boolean pending,
397 final boolean transfer, final boolean error,
398 final boolean done, final boolean all) {
399 final StringBuilder builder = new StringBuilder(header);
400 WaarpStringUtils.replace(builder, "XXXSTARTIDXXX", startid);
401 WaarpStringUtils.replace(builder, "XXXSTOPIDXXX", stopid);
402 WaarpStringUtils.replace(builder, "XXXSTARTXXX", start);
403 WaarpStringUtils.replace(builder, "XXXSTOPXXX", stop);
404 WaarpStringUtils.replace(builder, "XXXRULEXXX", rule);
405 WaarpStringUtils.replace(builder, "XXXREQXXX", req);
406 WaarpStringUtils.replace(builder, "XXXPENDXXX", pending? CHECKED : "");
407 WaarpStringUtils.replace(builder, "XXXTRANSXXX", transfer? CHECKED : "");
408 WaarpStringUtils.replace(builder, "XXXERRXXX", error? CHECKED : "");
409 WaarpStringUtils.replace(builder, "XXXDONEXXX", done? CHECKED : "");
410 WaarpStringUtils.replace(builder, "XXXALLXXX", all? CHECKED : "");
411 return builder.toString();
412 }
413
414 final String checkAuthorizedToSeeAll() {
415 boolean seeAll = false;
416 if (authentHttp.getAuth().isValidRole(ROLE.CONFIGADMIN)) {
417 final DbHostConfiguration dbhc;
418 try {
419 dbhc = new DbHostConfiguration(Configuration.configuration.getHostId());
420 } catch (final WaarpDatabaseException e) {
421 return null;
422 }
423 seeAll = dbhc != null && dbhc.isSeeAllId(authentHttp.getAuth().getUser());
424 }
425 if (seeAll) {
426 return "*";
427 }
428 return null;
429 }
430
431 private String listing0() {
432 getParams();
433 if (params == null) {
434 String head = REQUEST.Listing.readHeader(this);
435 head =
436 resetOptionTransfer(head, "", "", "", "", "", "", false, false, false,
437 false, true);
438 final String end = REQUEST.Listing.readEnd().replace(XXXRESULTXXX, "");
439 return head + end;
440 }
441 String head = REQUEST.Listing.readHeader(this);
442 String body0;
443 String body;
444 String body1;
445 body0 = body1 = body = "";
446 final StringBuilder endText = new StringBuilder();
447 final List<String> parms = params.get(ACTION);
448 if (parms != null) {
449 body0 = REQUEST.Listing.readBodyHeader();
450 final String parm = parms.get(0);
451 final boolean isNotReload = !"Reload".equalsIgnoreCase(parm);
452 if (FILTER.equalsIgnoreCase(parm) || !isNotReload) {
453 String startid = getTrimValue(STARTID2);
454 String stopid = getTrimValue(STOPID2);
455 if (isNotReload && startid != null && stopid == null) {
456 stopid = Long.MAX_VALUE + "";
457 }
458 if (isNotReload && stopid != null && startid == null) {
459 startid = (DbConstantR66.ILLEGALVALUE + 1) + "";
460 }
461 String start = getValue(START2);
462 String stop = getValue("stop");
463 final String rule = getTrimValue("rule");
464 final String req = getTrimValue("req");
465 final boolean pending;
466 final boolean transfer;
467 final boolean error;
468 final boolean done;
469 boolean all;
470 pending = params.containsKey(PENDING2);
471 transfer = params.containsKey(TRANSFER2);
472 error = params.containsKey(ERROR2);
473 done = params.containsKey("done");
474 all = params.containsKey("all");
475 if (pending && transfer && error && done) {
476 all = true;
477 } else if (!(pending || transfer || error || done)) {
478 all = true;
479 }
480 final Timestamp tstart = WaarpStringUtils.fixDate(start);
481 if (tstart != null) {
482 start = tstart.toString();
483 }
484 final Timestamp tstop = WaarpStringUtils.fixDate(stop, tstart);
485 if (tstop != null) {
486 stop = tstop.toString();
487 }
488 Long idstart = null;
489 body = REQUEST.Listing.readBody();
490 final String seeAll = checkAuthorizedToSeeAll();
491 DbPreparedStatement preparedStatement = null;
492 try {
493 preparedStatement =
494 DbTaskRunner.getFilterPrepareStatement(dbSession, getLimitRow(),
495 false, startid, stopid,
496 tstart, tstop, rule, req,
497 pending, transfer, error,
498 done, all, seeAll);
499 preparedStatement.executeQuery();
500 final StringBuilder builder = new StringBuilder();
501 int i = 0;
502 while (preparedStatement.getNext()) {
503 try {
504 i++;
505 final DbTaskRunner taskRunner =
506 DbTaskRunner.getFromStatementNoRule(preparedStatement);
507 if (isNotReload) {
508 final long specid = taskRunner.getSpecialId();
509 if (idstart == null || idstart > specid) {
510 idstart = specid;
511 }
512 }
513 final LocalChannelReference lcr =
514 Configuration.configuration.getLocalTransaction()
515 .getFromRequest(
516 taskRunner.getKey());
517 builder.append(taskRunner.toSpecializedHtml(authentHttp, body,
518 lcr != null?
519 Messages.getString(
520 HTTP_SSL_HANDLER_ACTIVE) :
521 Messages.getString(
522 HTTP_SSL_HANDLER_NOT_ACTIVE)));
523 if (i > getLimitRow()) {
524 break;
525 }
526 } catch (final WaarpDatabaseException e) {
527
528 logger.warn(AN_ERROR_OCCURS_WHILE_ACCESSING_A_RUNNER,
529 e.getMessage());
530 endText.append(e.getMessage()).append("</BR>");
531 }
532 }
533 preparedStatement.realClose();
534 body = builder.toString();
535 } catch (final WaarpDatabaseException e) {
536 if (preparedStatement != null) {
537 preparedStatement.realClose();
538 }
539 logger.warn(OPEN_R66_WEB_ERROR, e.getMessage());
540 }
541 head = resetOptionTransfer(head, startid == null?
542 idstart != null? idstart.toString() : "" : startid,
543 stopid == null? "" : stopid, start, stop,
544 rule == null? "" : rule,
545 req == null? "" : req, pending, transfer,
546 error, done, all);
547 } else {
548 head = resetOptionTransfer(head, "", "", "", "", "", "", false, false,
549 false, false, true);
550 }
551 body1 = REQUEST.Listing.readBodyEnd();
552 } else {
553 head =
554 resetOptionTransfer(head, "", "", "", "", "", "", false, false, false,
555 false, true);
556 }
557 final String end =
558 REQUEST.Listing.readEnd().replace(XXXRESULTXXX, endText.toString());
559 return head + body0 + body + body1 + end;
560 }
561
562 private String cancelRestart0() {
563 getParams();
564 if (params == null) {
565 String head = REQUEST.CancelRestart.readHeader(this);
566 head =
567 resetOptionTransfer(head, "", "", "", "", "", "", false, false, false,
568 false, true);
569 final String end;
570 end = REQUEST.CancelRestart.readEnd();
571 return head + end;
572 }
573 String head = REQUEST.CancelRestart.readHeader(this);
574 String body0;
575 String body;
576 String body1;
577 body0 = body1 = body = "";
578 final List<String> parms = params.get(ACTION);
579 final String seeAll = checkAuthorizedToSeeAll();
580 if (parms != null) {
581 body0 = REQUEST.CancelRestart.readBodyHeader();
582 final String parm = parms.get(0);
583 final boolean isNotReload = !"Reload".equalsIgnoreCase(parm);
584 if (FILTER.equalsIgnoreCase(parm) || !isNotReload) {
585 String startid = getTrimValue(STARTID2);
586 String stopid = getTrimValue(STOPID2);
587 if (isNotReload && startid != null && stopid == null) {
588 stopid = Long.MAX_VALUE + "";
589 }
590 if (isNotReload && stopid != null && startid == null) {
591 startid = (DbConstantR66.ILLEGALVALUE + 1) + "";
592 }
593 String start = getValue(START2);
594 String stop = getValue("stop");
595 final String rule = getTrimValue("rule");
596 final String req = getTrimValue("req");
597 final boolean pending;
598 final boolean transfer;
599 final boolean error;
600 final boolean done;
601 boolean all;
602 pending = params.containsKey(PENDING2);
603 transfer = params.containsKey(TRANSFER2);
604 error = params.containsKey(ERROR2);
605 done = params.containsKey("done");
606 all = params.containsKey("all");
607 if (pending && transfer && error && done) {
608 all = true;
609 } else if (!(pending || transfer || error || done)) {
610 all = true;
611 }
612 final Timestamp tstart = WaarpStringUtils.fixDate(start);
613 if (tstart != null) {
614 start = tstart.toString();
615 }
616 final Timestamp tstop = WaarpStringUtils.fixDate(stop, tstart);
617 if (tstop != null) {
618 stop = tstop.toString();
619 }
620 body = REQUEST.CancelRestart.readBody();
621 Long idstart = null;
622 DbPreparedStatement preparedStatement = null;
623 try {
624 preparedStatement =
625 DbTaskRunner.getFilterPrepareStatement(dbSession, getLimitRow(),
626 false, startid, stopid,
627 tstart, tstop, rule, req,
628 pending, transfer, error,
629 done, all, seeAll);
630 preparedStatement.executeQuery();
631 final StringBuilder builder = new StringBuilder();
632 int i = 0;
633 while (preparedStatement.getNext()) {
634 try {
635 i++;
636 final DbTaskRunner taskRunner =
637 DbTaskRunner.getFromStatementNoRule(preparedStatement);
638 if (isNotReload) {
639 final long specid = taskRunner.getSpecialId();
640 if (idstart == null || idstart > specid) {
641 idstart = specid;
642 }
643 }
644 final LocalChannelReference lcr =
645 Configuration.configuration.getLocalTransaction()
646 .getFromRequest(
647 taskRunner.getKey());
648 builder.append(taskRunner.toSpecializedHtml(authentHttp, body,
649 lcr != null?
650 Messages.getString(
651 HTTP_SSL_HANDLER_ACTIVE) :
652 Messages.getString(
653 HTTP_SSL_HANDLER_NOT_ACTIVE)));
654 if (i > getLimitRow()) {
655 break;
656 }
657 } catch (final WaarpDatabaseException e) {
658
659 logger.warn(AN_ERROR_OCCURS_WHILE_ACCESSING_A_RUNNER,
660 e.getMessage());
661 }
662 }
663 preparedStatement.realClose();
664 body = builder.toString();
665 } catch (final WaarpDatabaseException e) {
666 if (preparedStatement != null) {
667 preparedStatement.realClose();
668 }
669 logger.warn(OPEN_R66_WEB_ERROR, e.getMessage());
670 }
671 head = resetOptionTransfer(head, startid == null?
672 idstart != null? idstart.toString() : "" : startid,
673 stopid == null? "" : stopid, start, stop,
674 rule == null? "" : rule,
675 req == null? "" : req, pending, transfer,
676 error, done, all);
677 body1 = REQUEST.CancelRestart.readBodyEnd();
678 } else if ("RestartAll".equalsIgnoreCase(parm) ||
679 "StopAll".equalsIgnoreCase(parm) ||
680 "StopCleanAll".equalsIgnoreCase(parm)) {
681 final boolean stopcommand = "StopAll".equalsIgnoreCase(parm) ||
682 "StopCleanAll".equalsIgnoreCase(parm);
683 final String startid = getTrimValue(STARTID2);
684 final String stopid = getTrimValue(STOPID2);
685 String start = getValue(START2);
686 String stop = getValue("stop");
687 final String rule = getTrimValue("rule");
688 final String req = getTrimValue("req");
689 boolean pending;
690 boolean transfer;
691 boolean error;
692 final boolean done;
693 boolean all;
694 pending = params.containsKey(PENDING2);
695 transfer = params.containsKey(TRANSFER2);
696 error = params.containsKey(ERROR2);
697 done = false;
698 all = false;
699 if (!(pending || transfer || error)) {
700 all = true;
701 pending = true;
702 transfer = true;
703 error = true;
704 }
705 final Timestamp tstart = WaarpStringUtils.fixDate(start);
706 if (tstart != null) {
707 start = tstart.toString();
708 }
709 final Timestamp tstop = WaarpStringUtils.fixDate(stop, tstart);
710 if (tstop != null) {
711 stop = tstop.toString();
712 }
713 head = resetOptionTransfer(head, startid == null? "" : startid,
714 stopid == null? "" : stopid, start, stop,
715 rule == null? "" : rule,
716 req == null? "" : req, pending, transfer,
717 error, false, all);
718 body = REQUEST.CancelRestart.readBody();
719 final StringBuilder builder = new StringBuilder();
720 if (stopcommand) {
721 if ("StopCleanAll".equalsIgnoreCase(parm)) {
722 TransferUtils.cleanSelectedTransfers(dbSession, 0, builder,
723 authentHttp, body, startid,
724 stopid, tstart, tstop, rule,
725 req, pending, transfer, error,
726 seeAll);
727 } else {
728 TransferUtils.stopSelectedTransfers(dbSession, 0, builder,
729 authentHttp, body, startid,
730 stopid, tstart, tstop, rule,
731 req, pending, transfer, error,
732 seeAll);
733 }
734 } else {
735 DbPreparedStatement preparedStatement = null;
736 try {
737 preparedStatement =
738 DbTaskRunner.getFilterPrepareStatement(dbSession, 0, false,
739 startid, stopid, tstart,
740 tstop, rule, req,
741 pending, transfer, error,
742 false, all, seeAll);
743 preparedStatement.executeQuery();
744 while (preparedStatement.getNext()) {
745 try {
746 final DbTaskRunner taskRunner =
747 DbTaskRunner.getFromStatement(preparedStatement);
748 final LocalChannelReference lcr =
749 Configuration.configuration.getLocalTransaction()
750 .getFromRequest(
751 taskRunner.getKey());
752 final R66Result finalResult =
753 TransferUtils.restartTransfer(taskRunner, lcr);
754 final ErrorCode result = finalResult.getCode();
755 final ErrorCode last = taskRunner.getErrorInfo();
756 taskRunner.setErrorExecutionStatus(result);
757 builder.append(taskRunner.toSpecializedHtml(authentHttp, body,
758 lcr != null?
759 Messages.getString(
760 HTTP_SSL_HANDLER_ACTIVE) :
761 Messages.getString(
762 HTTP_SSL_HANDLER_NOT_ACTIVE)));
763 taskRunner.setErrorExecutionStatus(last);
764 } catch (final WaarpDatabaseException e) {
765
766 logger.warn(AN_ERROR_OCCURS_WHILE_ACCESSING_A_RUNNER,
767 e.getMessage());
768 }
769 }
770 preparedStatement.realClose();
771 } catch (final WaarpDatabaseException e) {
772 if (preparedStatement != null) {
773 preparedStatement.realClose();
774 }
775 logger.warn(OPEN_R66_WEB_ERROR, e.getMessage());
776 }
777 }
778 if (builder != null) {
779 body = builder.toString();
780 }
781 body1 = REQUEST.CancelRestart.readBodyEnd();
782 } else if ("Cancel".equalsIgnoreCase(parm) ||
783 "CancelClean".equalsIgnoreCase(parm) ||
784 "Stop".equalsIgnoreCase(parm)) {
785
786 final boolean stop = "Stop".equalsIgnoreCase(parm);
787 final String specid = getValue("specid");
788 final String reqd = getValue("reqd");
789 final String reqr = getValue("reqr");
790 final LocalChannelReference lcr =
791 Configuration.configuration.getLocalTransaction().getFromRequest(
792 reqd + ' ' + reqr + ' ' + specid);
793
794 ErrorCode result;
795 final long lspecid;
796 try {
797 lspecid = Long.parseLong(specid);
798 } catch (final NumberFormatException e) {
799 body = "";
800 body1 = REQUEST.CancelRestart.readBodyEnd();
801 body1 += BR_B + parm +
802 Messages.getString(HTTP_SSL_HANDLER_3);
803 final String end;
804 end = REQUEST.CancelRestart.readEnd();
805 return head + body0 + body + body1 + end;
806 }
807 DbTaskRunner taskRunner = null;
808 try {
809 taskRunner = new DbTaskRunner(authentHttp, null, lspecid, reqr, reqd);
810 } catch (final WaarpDatabaseException ignored) {
811
812 }
813 if (taskRunner == null) {
814 body = "";
815 body1 = REQUEST.CancelRestart.readBodyEnd();
816 body1 += BR_B + parm +
817 Messages.getString(HTTP_SSL_HANDLER_3);
818 final String end;
819 end = REQUEST.CancelRestart.readEnd();
820 return head + body0 + body + body1 + end;
821 }
822 final ErrorCode code =
823 stop? ErrorCode.StoppedTransfer : ErrorCode.CanceledTransfer;
824 if (lcr != null) {
825 final int rank = taskRunner.getRank();
826 lcr.sessionNewState(R66FiniteDualStates.ERROR);
827 final ErrorPacket error =
828 new ErrorPacket("Transfer " + parm + ' ' + rank, code.getCode(),
829 ErrorPacket.FORWARDCLOSECODE);
830 try {
831
832 LocalServerHandler.channelRead0(lcr, error);
833 } catch (final Exception ignored) {
834
835 }
836 result = ErrorCode.CompleteOk;
837 } else {
838
839
840 result = ErrorCode.TransferOk;
841 if (taskRunner.stopOrCancelRunner(code)) {
842 result = ErrorCode.CompleteOk;
843 }
844 }
845 if ("CancelClean".equalsIgnoreCase(parm)) {
846 TransferUtils.cleanOneTransfer(taskRunner, null, authentHttp, null);
847 }
848 body = REQUEST.CancelRestart.readBody();
849 body = taskRunner.toSpecializedHtml(authentHttp, body, lcr != null?
850 Messages.getString(HTTP_SSL_HANDLER_ACTIVE)
851
852 : Messages.getString(HTTP_SSL_HANDLER_NOT_ACTIVE));
853 final String tstart = taskRunner.getStart().toString();
854 final String tstop = taskRunner.getStop().toString();
855 head = resetOptionTransfer(head, String.valueOf(
856 taskRunner.getSpecialId() - 1), String.valueOf(
857 taskRunner.getSpecialId() + 1), tstart, tstop,
858 taskRunner.getRuleId(),
859 taskRunner.getRequested(), false, false,
860 false, false, true);
861 body1 = REQUEST.CancelRestart.readBodyEnd();
862 body1 += BR_B + (result == ErrorCode.CompleteOk?
863 parm + Messages.getString("HttpSslHandler.5") :
864
865 parm + Messages.getString("HttpSslHandler.4")) +
866 "</b>";
867 } else if ("Restart".equalsIgnoreCase(parm)) {
868
869 final String specid = getValue("specid");
870 final String reqd = getValue("reqd");
871 final String reqr = getValue("reqr");
872 final long lspecid;
873 try {
874 lspecid = Long.parseLong(specid);
875 } catch (final NumberFormatException e) {
876 body = "";
877 body1 = REQUEST.CancelRestart.readBodyEnd();
878 body1 += BR_B + parm +
879 Messages.getString(HTTP_SSL_HANDLER_3);
880 final String end;
881 end = REQUEST.CancelRestart.readEnd();
882 return head + body0 + body + body1 + end;
883 }
884 final DbTaskRunner taskRunner;
885 String comment;
886 try {
887 taskRunner = new DbTaskRunner(authentHttp, null, lspecid, reqr, reqd);
888 final LocalChannelReference lcr =
889 Configuration.configuration.getLocalTransaction()
890 .getFromRequest(taskRunner.getKey());
891 final R66Result finalResult =
892 TransferUtils.restartTransfer(taskRunner, lcr);
893 comment = (String) finalResult.getOther();
894 body = REQUEST.CancelRestart.readBody();
895 body = taskRunner.toSpecializedHtml(authentHttp, body, lcr != null?
896 Messages.getString(HTTP_SSL_HANDLER_ACTIVE)
897
898 : Messages.getString(HTTP_SSL_HANDLER_NOT_ACTIVE));
899 final String tstart = taskRunner.getStart().toString();
900 final String tstop = taskRunner.getStop().toString();
901 head = resetOptionTransfer(head, String.valueOf(
902 taskRunner.getSpecialId() - 1), String.valueOf(
903 taskRunner.getSpecialId() + 1), tstart, tstop,
904 taskRunner.getRuleId(),
905 taskRunner.getRequested(), false, false,
906 false, false, true);
907 } catch (final WaarpDatabaseException e) {
908 body = "";
909 comment = Messages.getString("ErrorCode.17");
910 }
911 body1 = REQUEST.CancelRestart.readBodyEnd();
912 body1 += BR_B + comment + "</b>";
913 } else {
914 head = resetOptionTransfer(head, "", "", "", "", "", "", false, false,
915 false, false, true);
916 }
917 } else {
918 head =
919 resetOptionTransfer(head, "", "", "", "", "", "", false, false, false,
920 false, true);
921 }
922 final String end;
923 end = REQUEST.CancelRestart.readEnd();
924 return head + body0 + body + body1 + end;
925 }
926
927 private String export0() {
928 getParams();
929 if (params == null) {
930 String body = REQUEST.Export.readFileUnique(this);
931 body =
932 resetOptionTransfer(body, "", "", "", "", "", "", false, false, false,
933 true, false);
934 return body.replace(XXXRESULTXXX, "");
935 }
936 String body = REQUEST.Export.readFileUnique(this);
937 String start = getValue(START2);
938 String stop = getValue("stop");
939 final String rule = getTrimValue("rule");
940 final String req = getTrimValue("req");
941 final boolean pending;
942 boolean transfer;
943 final boolean error;
944 final boolean done;
945 boolean all;
946 pending = params.containsKey(PENDING2);
947 transfer = params.containsKey(TRANSFER2);
948 error = params.containsKey(ERROR2);
949 done = params.containsKey("done");
950 all = params.containsKey("all");
951 boolean toPurge = params.containsKey("purge");
952 if (toPurge) {
953 transfer = false;
954 }
955 if (pending && transfer && error && done) {
956 all = true;
957 } else if (!(pending || transfer || error || done)) {
958 all = true;
959 }
960 final Timestamp tstart = WaarpStringUtils.fixDate(start);
961 if (tstart != null) {
962 start = tstart.toString();
963 }
964 final Timestamp tstop = WaarpStringUtils.fixDate(stop, tstart);
965 if (tstop != null) {
966 stop = tstop.toString();
967 }
968 body =
969 resetOptionTransfer(body, "", "", start, stop, rule == null? "" : rule,
970 req == null? "" : req, pending, transfer, error,
971 done, all);
972 boolean isexported = true;
973
974 try {
975 DbTaskRunner.changeFinishedToDone();
976 } catch (final WaarpDatabaseNoConnectionException e2) {
977
978 }
979
980 DbPreparedStatement getValid = null;
981 NbAndSpecialId nbAndSpecialId = null;
982 final String filename = Configuration.configuration.getBaseDirectory() +
983 Configuration.configuration.getArchivePath() +
984 DirInterface.SEPARATOR +
985 Configuration.configuration.getHostId() + '_' +
986 System.currentTimeMillis() + "_runners.xml";
987 String errorMsg = "";
988 final String seeAll = checkAuthorizedToSeeAll();
989 try {
990 getValid = DbTaskRunner.getFilterPrepareStatement(dbSession, 0,
991
992 true, null, null,
993 tstart, tstop, rule,
994 req, pending, transfer,
995 error, done, all,
996 seeAll);
997 nbAndSpecialId = DbTaskRunner.writeXMLWriter(getValid, filename);
998 } catch (final WaarpDatabaseNoConnectionException e1) {
999 isexported = false;
1000 toPurge = false;
1001 logger.warn(EXPORT_ERROR, e1.getMessage());
1002 errorMsg = e1.getMessage();
1003 } catch (final WaarpDatabaseSqlException e1) {
1004 isexported = false;
1005 toPurge = false;
1006 logger.warn(EXPORT_ERROR, e1.getMessage());
1007 errorMsg = e1.getMessage();
1008 } catch (final OpenR66ProtocolBusinessException e) {
1009 isexported = false;
1010 toPurge = false;
1011 logger.warn(EXPORT_ERROR, e.getMessage());
1012 errorMsg = e.getMessage();
1013 } finally {
1014 if (getValid != null) {
1015 getValid.realClose();
1016 }
1017 }
1018 int purge = 0;
1019 if (isexported && nbAndSpecialId != null) {
1020 if (nbAndSpecialId.nb <= 0) {
1021 return body.replace(XXXRESULTXXX, Messages.getString(
1022 "HttpSslHandler.7"));
1023 }
1024
1025 if (toPurge) {
1026
1027
1028
1029 final String stopId = Long.toString(nbAndSpecialId.higherSpecialId);
1030 try {
1031 purge = DbTaskRunner.purgeLogPrepareStatement(dbSession, null, stopId,
1032 tstart, tstop, rule,
1033 req, pending, transfer,
1034 error, done, all);
1035 } catch (final WaarpDatabaseNoConnectionException ignored) {
1036
1037 } catch (final WaarpDatabaseSqlException e) {
1038 logger.warn("Purge error: {}", e.getMessage());
1039 }
1040 }
1041 }
1042 return body.replace(XXXRESULTXXX, "Export " + (isexported?
1043 "<B>" + Messages.getString("HttpSslHandler.8") +
1044 filename + Messages.getString("HttpSslHandler.9") +
1045 (nbAndSpecialId != null? nbAndSpecialId.nb : 0) +
1046 Messages.getString("HttpSslHandler.10")
1047
1048 + purge + Messages.getString("HttpSslHandler.11") + "</B>" :
1049
1050 "<B>" + Messages.getString("HttpSslHandler.12"))) + "</B>" +
1051 errorMsg;
1052 }
1053
1054 final String resetOptionHosts(final String header, final String host,
1055 final String addr, final boolean ssl,
1056 final boolean active) {
1057 final StringBuilder builder = new StringBuilder(header);
1058 WaarpStringUtils.replace(builder, "XXXFHOSTXXX", host);
1059 WaarpStringUtils.replace(builder, "XXXFADDRXXX", addr);
1060 WaarpStringUtils.replace(builder, "XXXFSSLXXX", ssl? CHECKED : "");
1061 WaarpStringUtils.replace(builder, "XXXFACTIVXXX", active? CHECKED : "");
1062 return builder.toString();
1063 }
1064
1065 private String hosts0() {
1066 getParams();
1067 String head = REQUEST.Hosts.readHeader(this);
1068 final String end;
1069 end = REQUEST.Hosts.readEnd();
1070 if (params == null) {
1071 head = resetOptionHosts(head, "", "", false, true);
1072 return head + end;
1073 }
1074 String body0;
1075 String body;
1076 String body1;
1077 body0 = body1 = body = "";
1078 final List<String> parms = params.get(ACTION);
1079 if (parms != null) {
1080 body0 = REQUEST.Hosts.readBodyHeader();
1081 final String parm = parms.get(0);
1082 if (CREATE.equalsIgnoreCase(parm)) {
1083 final String host = getTrimValue("host");
1084 final String addr = getTrimValue(ADDRESS);
1085 final String port = getTrimValue("port");
1086 final String key = getTrimValue("hostkey");
1087 final boolean ssl;
1088 final boolean adminArg;
1089 final boolean isclient;
1090 final boolean isactive;
1091 final boolean isproxified;
1092 ssl = params.containsKey("ssl");
1093 adminArg = params.containsKey("admin");
1094 isclient = params.containsKey("isclient");
1095 isactive = params.containsKey("isactive");
1096 isproxified = params.containsKey("isproxified");
1097 if (host == null || addr == null || port == null || key == null) {
1098 body0 = body1 = body = "";
1099 body = Messages.getString("HttpSslHandler.13");
1100 head = resetOptionHosts(head, "", "", ssl, isactive);
1101 return head + body0 + body + body1 + end;
1102 }
1103 final int iport;
1104 try {
1105 iport = Integer.parseInt(port);
1106 } catch (final NumberFormatException e1) {
1107 body0 = body1 = body = "";
1108 body = Messages.getString("HttpSslHandler.14") + e1.getMessage() +
1109 B_CENTER_P;
1110 head = resetOptionHosts(head, "", "", ssl, isactive);
1111 return head + body0 + body + body1 + end;
1112 }
1113 final DbHostAuth dbhost;
1114 try {
1115 dbhost = new DbHostAuth(host, addr, iport, ssl,
1116 key.getBytes(WaarpStringUtils.UTF8), adminArg,
1117 isclient);
1118 dbhost.setActive(isactive);
1119 dbhost.setProxified(isproxified);
1120 dbhost.insert();
1121 } catch (final WaarpDatabaseException e) {
1122 body0 = body1 = body = "";
1123 body = Messages.getString("HttpSslHandler.14") + e.getMessage()
1124
1125 + B_CENTER_P;
1126 head = resetOptionHosts(head, "", "", ssl, isactive);
1127 return head + body0 + body + body1 + end;
1128 }
1129 head = resetOptionHosts(head, host, addr, ssl, isactive);
1130 body = REQUEST.Hosts.readBody();
1131 body = dbhost.toSpecializedHtml(authentHttp, body, false);
1132 } else if (FILTER.equalsIgnoreCase(parm)) {
1133 final String host = getTrimValue("host");
1134 final String addr = getTrimValue(ADDRESS);
1135 final boolean ssl = params.containsKey("ssl");
1136 final boolean isactive = params.containsKey("active");
1137 head = resetOptionHosts(head, host == null? "" : host,
1138 addr == null? "" : addr, ssl, isactive);
1139 body = REQUEST.Hosts.readBody();
1140 DbPreparedStatement preparedStatement = null;
1141 try {
1142 preparedStatement =
1143 DbHostAuth.getFilterPrepareStament(dbSession, host, addr, ssl,
1144 isactive);
1145 preparedStatement.executeQuery();
1146 final StringBuilder builder = new StringBuilder();
1147 int i = 0;
1148 while (preparedStatement.getNext()) {
1149 i++;
1150 final DbHostAuth dbhost =
1151 DbHostAuth.getFromStatement(preparedStatement);
1152 builder.append(dbhost.toSpecializedHtml(authentHttp, body, false));
1153 if (i > getLimitRow()) {
1154 break;
1155 }
1156 }
1157 preparedStatement.realClose();
1158 body = builder.toString();
1159 } catch (final WaarpDatabaseException e) {
1160 if (preparedStatement != null) {
1161 preparedStatement.realClose();
1162 }
1163 logger.warn(OPEN_R66_WEB_ERROR, e.getMessage());
1164 }
1165 body1 = REQUEST.Hosts.readBodyEnd();
1166 } else if ("Update".equalsIgnoreCase(parm)) {
1167 final String host = getTrimValue("host");
1168 final String addr = getTrimValue(ADDRESS);
1169 final String port = getTrimValue("port");
1170 final String key = getTrimValue("hostkey");
1171 final boolean ssl;
1172 final boolean adminArg;
1173 final boolean isclient;
1174 final boolean isactive;
1175 final boolean isproxified;
1176 ssl = params.containsKey("ssl");
1177 adminArg = params.containsKey("admin");
1178 isclient = params.containsKey("isclient");
1179 isactive = params.containsKey("isactive");
1180 isproxified = params.containsKey("isproxified");
1181 if (host == null || addr == null || port == null || key == null) {
1182 body0 = body1 = body = "";
1183 body = Messages.getString("HttpSslHandler.15");
1184 head = resetOptionHosts(head, "", "", ssl, isactive);
1185 return head + body0 + body + body1 + end;
1186 }
1187 final int iport;
1188 try {
1189 iport = Integer.parseInt(port);
1190 } catch (final NumberFormatException e1) {
1191 body0 = body1 = body = "";
1192 body = Messages.getString("HttpSslHandler.16") + e1.getMessage() +
1193 B_CENTER_P;
1194 head = resetOptionHosts(head, "", "", ssl, isactive);
1195 return head + body0 + body + body1 + end;
1196 }
1197 final DbHostAuth dbhost;
1198 try {
1199 dbhost = new DbHostAuth(host, addr, iport, ssl,
1200 key.getBytes(WaarpStringUtils.UTF8), adminArg,
1201 isclient);
1202 dbhost.setActive(isactive);
1203 dbhost.setProxified(isproxified);
1204 if (dbhost.exist()) {
1205 dbhost.update();
1206 } else {
1207 dbhost.insert();
1208 }
1209 } catch (final WaarpDatabaseException e) {
1210 body0 = body1 = body = "";
1211 body = Messages.getString("HttpSslHandler.16") + e.getMessage()
1212
1213 + B_CENTER_P;
1214 head = resetOptionHosts(head, "", "", ssl, isactive);
1215 return head + body0 + body + body1 + end;
1216 }
1217 head = resetOptionHosts(head, host, addr, ssl, isactive);
1218 body = REQUEST.Hosts.readBody();
1219 body = dbhost.toSpecializedHtml(authentHttp, body, false);
1220 } else if ("TestConn".equalsIgnoreCase(parm)) {
1221 final String host = getTrimValue("host");
1222 if (ParametersChecker.isEmpty(host)) {
1223 body0 = body1 = body = "";
1224 body = Messages.getString(HTTP_SSL_HANDLER_17);
1225 head = resetOptionHosts(head, "", "", false, true);
1226 return head + body0 + body + body1 + end;
1227 }
1228 final DbHostAuth dbhost;
1229 try {
1230 dbhost = new DbHostAuth(host);
1231 } catch (final WaarpDatabaseException e) {
1232 body0 = body1 = body = "";
1233 body = Messages.getString(HTTP_SSL_HANDLER_17) + e.getMessage()
1234
1235 + B_CENTER_P;
1236 head = resetOptionHosts(head, "", "", false, true);
1237 return head + body0 + body + body1 + end;
1238 }
1239 final R66Future result = new R66Future(true);
1240 final TestPacket packet = new TestPacket("MSG", "CheckConnection", 100);
1241 final Message transaction = new Message(
1242 Configuration.configuration.getInternalRunner()
1243 .getNetworkTransaction(), result, dbhost,
1244 packet);
1245 transaction.run();
1246 result.awaitOrInterruptible();
1247 head =
1248 resetOptionHosts(head, "", "", dbhost.isSsl(), dbhost.isActive());
1249 body = REQUEST.Hosts.readBody();
1250 if (result.isSuccess()) {
1251 body = dbhost.toSpecializedHtml(authentHttp, body, false);
1252 body += Messages.getString("HttpSslHandler.18");
1253 } else {
1254 body = dbhost.toSpecializedHtml(authentHttp, body, false);
1255 body += Messages.getString("HttpSslHandler.19")
1256 + result.getResult().getCode().getMesg() + B_CENTER_P;
1257 }
1258 } else if ("CloseConn".equalsIgnoreCase(parm)) {
1259 final String host = getTrimValue("host");
1260 if (ParametersChecker.isEmpty(host)) {
1261 body0 = body1 = body = "";
1262 body = Messages.getString(HTTP_SSL_HANDLER_17);
1263 head = resetOptionHosts(head, "", "", false, true);
1264 return head + body0 + body + body1 + end;
1265 }
1266 final DbHostAuth dbhost;
1267 try {
1268 dbhost = new DbHostAuth(host);
1269 } catch (final WaarpDatabaseException e) {
1270 body0 = body1 = body = "";
1271 body = Messages.getString(HTTP_SSL_HANDLER_17) + e.getMessage()
1272
1273 + B_CENTER_P;
1274 head = resetOptionHosts(head, "", "", false, true);
1275 return head + body0 + body + body1 + end;
1276 }
1277 body = REQUEST.Hosts.readBody();
1278 final boolean resultShutDown =
1279 NetworkTransaction.shuttingdownNetworkChannelsPerHostID(
1280 dbhost.getHostid());
1281 head =
1282 resetOptionHosts(head, "", "", dbhost.isSsl(), dbhost.isActive());
1283 if (resultShutDown) {
1284 body = dbhost.toSpecializedHtml(authentHttp, body, false);
1285 body += Messages.getString("HttpSslHandler.21");
1286 } else {
1287 body = dbhost.toSpecializedHtml(authentHttp, body, false);
1288 body += Messages.getString("HttpSslHandler.22");
1289 }
1290 } else if ("Delete".equalsIgnoreCase(parm)) {
1291 final String host = getTrimValue("host");
1292 if (ParametersChecker.isEmpty(host)) {
1293 body0 = body1 = body = "";
1294 body = Messages.getString("HttpSslHandler.23");
1295 head = resetOptionHosts(head, "", "", false, true);
1296 return head + body0 + body + body1 + end;
1297 }
1298 final DbHostAuth dbhost;
1299 try {
1300 dbhost = new DbHostAuth(host);
1301 } catch (final WaarpDatabaseException e) {
1302 body0 = body1 = body = "";
1303 body = Messages.getString("HttpSslHandler.24") + e.getMessage()
1304
1305 + B_CENTER_P;
1306 head = resetOptionHosts(head, "", "", false, true);
1307 return head + body0 + body + body1 + end;
1308 }
1309 try {
1310 dbhost.delete();
1311 } catch (final WaarpDatabaseException e) {
1312 body0 = body1 = body = "";
1313 body = Messages.getString("HttpSslHandler.24") + e.getMessage()
1314
1315 + B_CENTER_P;
1316 head =
1317 resetOptionHosts(head, "", "", dbhost.isSsl(), dbhost.isActive());
1318 return head + body0 + body + body1 + end;
1319 }
1320 body0 = body1 = body = "";
1321 body = Messages.getString("HttpSslHandler.25") + host +
1322 B_CENTER_P;
1323 head = resetOptionHosts(head, "", "", false, dbhost.isActive());
1324 return head + body0 + body + body1 + end;
1325 } else {
1326 head = resetOptionHosts(head, "", "", false, true);
1327 }
1328 body1 = REQUEST.Hosts.readBodyEnd();
1329 } else {
1330 head = resetOptionHosts(head, "", "", false, true);
1331 }
1332 return head + body0 + body + body1 + end;
1333 }
1334
1335 private void createExport(final String body, final StringBuilder builder,
1336 final String rule, final int mode, final int limit,
1337 final int start) {
1338 DbPreparedStatement preparedStatement = null;
1339 try {
1340 preparedStatement = DbRule.getFilterPrepareStament(dbSession, rule, mode);
1341 preparedStatement.executeQuery();
1342 int i = 0;
1343 while (preparedStatement.getNext()) {
1344 final DbRule dbrule = DbRule.getFromStatement(preparedStatement);
1345 String temp = dbrule.toSpecializedHtml(authentHttp, body);
1346 temp = temp.replace("XXXRANKXXX", String.valueOf(start + i));
1347 builder.append(temp);
1348 i++;
1349 if (i > limit) {
1350 break;
1351 }
1352 }
1353 preparedStatement.realClose();
1354 } catch (final WaarpDatabaseException e) {
1355 if (preparedStatement != null) {
1356 preparedStatement.realClose();
1357 }
1358 logger.warn(OPEN_R66_WEB_ERROR, e.getMessage());
1359 }
1360 }
1361
1362 final String resetOptionRules(final String header, final String rule,
1363 final RequestPacket.TRANSFERMODE mode,
1364 final int gmode) {
1365 final StringBuilder builder = new StringBuilder(header);
1366 WaarpStringUtils.replace(builder, "XXXRULEXXX", rule);
1367 if (mode != null) {
1368 switch (mode) {
1369 case RECVMODE:
1370 WaarpStringUtils.replace(builder, "XXXRECVXXX", CHECKED);
1371 break;
1372 case SENDMODE:
1373 WaarpStringUtils.replace(builder, "XXXSENDXXX", CHECKED);
1374 break;
1375 case RECVMD5MODE:
1376 WaarpStringUtils.replace(builder, "XXXRECVMXXX", CHECKED);
1377 break;
1378 case SENDMD5MODE:
1379 WaarpStringUtils.replace(builder, "XXXSENDMXXX", CHECKED);
1380 break;
1381 case RECVTHROUGHMODE:
1382 WaarpStringUtils.replace(builder, "XXXRECVTXXX", CHECKED);
1383 break;
1384 case SENDTHROUGHMODE:
1385 WaarpStringUtils.replace(builder, "XXXSENDTXXX", CHECKED);
1386 break;
1387 case RECVMD5THROUGHMODE:
1388 WaarpStringUtils.replace(builder, "XXXRECVMTXXX", CHECKED);
1389 break;
1390 case SENDMD5THROUGHMODE:
1391 WaarpStringUtils.replace(builder, "XXXSENDMTXXX", CHECKED);
1392 break;
1393 default:
1394 break;
1395 }
1396 }
1397 if (gmode == -1) {
1398 WaarpStringUtils.replace(builder, "XXXARECVXXX", CHECKED);
1399 } else if (gmode == -2) {
1400 WaarpStringUtils.replace(builder, "XXXASENDXXX", CHECKED);
1401 } else if (gmode == -3) {
1402 WaarpStringUtils.replace(builder, "XXXALLXXX", CHECKED);
1403 }
1404 return builder.toString();
1405 }
1406
1407 private String rules0() {
1408 getParams();
1409 String head = REQUEST.Rules.readHeader(this);
1410 final String end;
1411 end = REQUEST.Rules.readEnd();
1412 if (params == null) {
1413 head = resetOptionRules(head, "", null, -3);
1414 return head + end;
1415 }
1416 String body0;
1417 String body;
1418 String body1;
1419 body0 = body1 = body = "";
1420 final List<String> parms = params.get(ACTION);
1421 if (parms != null) {
1422 body0 = REQUEST.Rules.readBodyHeader();
1423 final String parm = parms.get(0);
1424 if (CREATE.equalsIgnoreCase(parm) || "Update".equalsIgnoreCase(parm)) {
1425 final String rule = getTrimValue("rule");
1426 final String hostids = getTrimValue("hostids");
1427 final String recvp = getTrimValue("recvp");
1428 final String sendp = getTrimValue("sendp");
1429 final String archp = getTrimValue("archp");
1430 final String workp = getTrimValue("workp");
1431 final String rpre = getTrimValue("rpre");
1432 final String rpost = getTrimValue("rpost");
1433 final String rerr = getTrimValue("rerr");
1434 final String spre = getTrimValue("spre");
1435 final String spost = getTrimValue("spost");
1436 final String serr = getTrimValue("serr");
1437 final String mode = getTrimValue("mode");
1438 if (rule == null || mode == null) {
1439 body0 = body1 = body = "";
1440 body = Messages.getString("HttpSslHandler.26") + parm +
1441 Messages.getString(
1442 "HttpSslHandler.27");
1443 head = resetOptionRules(head, "", null, -3);
1444 return head + body0 + body + body1 + end;
1445 }
1446 int gmode = 0;
1447
1448 TRANSFERMODE tmode = null;
1449 if ("send".equals(mode)) {
1450 tmode = RequestPacket.TRANSFERMODE.SENDMODE;
1451 gmode = -2;
1452 } else if ("recv".equals(mode)) {
1453 tmode = RequestPacket.TRANSFERMODE.RECVMODE;
1454 gmode = -1;
1455 } else if ("sendmd5".equals(mode)) {
1456 tmode = RequestPacket.TRANSFERMODE.SENDMD5MODE;
1457 gmode = -2;
1458 } else if ("recvmd5".equals(mode)) {
1459 tmode = RequestPacket.TRANSFERMODE.RECVMD5MODE;
1460 gmode = -1;
1461 } else if ("sendth".equals(mode)) {
1462 tmode = RequestPacket.TRANSFERMODE.SENDTHROUGHMODE;
1463 gmode = -2;
1464 } else if ("recvth".equals(mode)) {
1465 tmode = RequestPacket.TRANSFERMODE.RECVTHROUGHMODE;
1466 gmode = -1;
1467 } else if ("sendthmd5".equals(mode)) {
1468 tmode = RequestPacket.TRANSFERMODE.SENDMD5THROUGHMODE;
1469 gmode = -2;
1470 } else if ("recvthmd5".equals(mode)) {
1471 tmode = RequestPacket.TRANSFERMODE.RECVMD5THROUGHMODE;
1472 gmode = -1;
1473 }
1474 head = resetOptionRules(head, rule, tmode, gmode);
1475 if (logger.isDebugEnabled()) {
1476 logger.debug("Recv UpdOrInsert: " + rule + ':' + hostids + ':' +
1477 (tmode != null? tmode.ordinal() : 0) + ':' + recvp +
1478 ':' + sendp + ':' + archp + ':' + workp + ':' + rpre +
1479 ':' + rpost + ':' + rerr + ':' + spre + ':' + spost +
1480 ':' + serr);
1481 }
1482 final DbRule dbrule;
1483 try {
1484 dbrule =
1485 new DbRule(rule, hostids, (tmode != null? tmode.ordinal() : 0),
1486 recvp, sendp, archp, workp, rpre, rpost, rerr, spre,
1487 spost, serr);
1488 if (CREATE.equalsIgnoreCase(parm)) {
1489 dbrule.insert();
1490 } else {
1491 if (dbrule.exist()) {
1492 dbrule.update();
1493 } else {
1494 dbrule.insert();
1495 }
1496 }
1497 } catch (final WaarpDatabaseException e) {
1498 body0 = body1 = body = "";
1499 body = Messages.getString("HttpSslHandler.28") + e.getMessage()
1500
1501 + B_CENTER_P;
1502 head = resetOptionRules(head, "", null, -3);
1503 return head + body0 + body + body1 + end;
1504 }
1505 body = REQUEST.Rules.readBody();
1506 body = dbrule.toSpecializedHtml(authentHttp, body);
1507 } else if (FILTER.equalsIgnoreCase(parm)) {
1508 final String rule = getTrimValue("rule");
1509 final String mode = getTrimValue("mode");
1510 TRANSFERMODE tmode;
1511 int gmode = 0;
1512 if ("all".equals(mode)) {
1513 gmode = -3;
1514 } else if ("send".equals(mode)) {
1515 gmode = -2;
1516 } else if ("recv".equals(mode)) {
1517 gmode = -1;
1518 }
1519 head = resetOptionRules(head, rule == null? "" : rule, null, gmode);
1520 body = REQUEST.Rules.readBody();
1521 final StringBuilder builder = new StringBuilder();
1522 boolean specific = false;
1523 int start = 1;
1524 if (params.containsKey("send")) {
1525 tmode = RequestPacket.TRANSFERMODE.SENDMODE;
1526 head = resetOptionRules(head, rule == null? "" : rule, tmode, gmode);
1527 specific = true;
1528 createExport(body, builder, rule,
1529 RequestPacket.TRANSFERMODE.SENDMODE.ordinal(),
1530 getLimitRow() / 4, start);
1531 start += getLimitRow() / 4 + 1;
1532 }
1533 if (params.containsKey("recv")) {
1534 tmode = RequestPacket.TRANSFERMODE.RECVMODE;
1535 head = resetOptionRules(head, rule == null? "" : rule, tmode, gmode);
1536 specific = true;
1537 createExport(body, builder, rule,
1538 RequestPacket.TRANSFERMODE.RECVMODE.ordinal(),
1539 getLimitRow() / 4, start);
1540 start += getLimitRow() / 4 + 1;
1541 }
1542 if (params.containsKey("sendmd5")) {
1543 tmode = RequestPacket.TRANSFERMODE.SENDMD5MODE;
1544 head = resetOptionRules(head, rule == null? "" : rule, tmode, gmode);
1545 specific = true;
1546 createExport(body, builder, rule,
1547 RequestPacket.TRANSFERMODE.SENDMD5MODE.ordinal(),
1548 getLimitRow() / 4, start);
1549 start += getLimitRow() / 4 + 1;
1550 }
1551 if (params.containsKey("recvmd5")) {
1552 tmode = RequestPacket.TRANSFERMODE.RECVMD5MODE;
1553 head = resetOptionRules(head, rule == null? "" : rule, tmode, gmode);
1554 specific = true;
1555 createExport(body, builder, rule,
1556 RequestPacket.TRANSFERMODE.RECVMD5MODE.ordinal(),
1557 getLimitRow() / 4, start);
1558 start += getLimitRow() / 4 + 1;
1559 }
1560 if (params.containsKey("sendth")) {
1561 tmode = RequestPacket.TRANSFERMODE.SENDTHROUGHMODE;
1562 head = resetOptionRules(head, rule == null? "" : rule, tmode, gmode);
1563 specific = true;
1564 createExport(body, builder, rule,
1565 RequestPacket.TRANSFERMODE.SENDTHROUGHMODE.ordinal(),
1566 getLimitRow() / 4, start);
1567 start += getLimitRow() / 4 + 1;
1568 }
1569 if (params.containsKey("recvth")) {
1570 tmode = RequestPacket.TRANSFERMODE.RECVTHROUGHMODE;
1571 head = resetOptionRules(head, rule == null? "" : rule, tmode, gmode);
1572 specific = true;
1573 createExport(body, builder, rule,
1574 RequestPacket.TRANSFERMODE.RECVTHROUGHMODE.ordinal(),
1575 getLimitRow() / 4, start);
1576 start += getLimitRow() / 4 + 1;
1577 }
1578 if (params.containsKey("sendthmd5")) {
1579 tmode = RequestPacket.TRANSFERMODE.SENDMD5THROUGHMODE;
1580 head = resetOptionRules(head, rule == null? "" : rule, tmode, gmode);
1581 specific = true;
1582 createExport(body, builder, rule,
1583 RequestPacket.TRANSFERMODE.SENDMD5THROUGHMODE.ordinal(),
1584 getLimitRow() / 4, start);
1585 start += getLimitRow() / 4 + 1;
1586 }
1587 if (params.containsKey("recvthmd5")) {
1588 tmode = RequestPacket.TRANSFERMODE.RECVMD5THROUGHMODE;
1589 head = resetOptionRules(head, rule == null? "" : rule, tmode, gmode);
1590 specific = true;
1591 createExport(body, builder, rule,
1592 RequestPacket.TRANSFERMODE.RECVMD5THROUGHMODE.ordinal(),
1593 getLimitRow() / 4, start);
1594 start += getLimitRow() / 4 + 1;
1595 }
1596 if (!specific) {
1597 if (gmode == -1) {
1598
1599 createExport(body, builder, rule,
1600 RequestPacket.TRANSFERMODE.RECVMODE.ordinal(),
1601 getLimitRow() / 4, start);
1602 start += getLimitRow() / 4 + 1;
1603 createExport(body, builder, rule,
1604 RequestPacket.TRANSFERMODE.RECVMD5MODE.ordinal(),
1605 getLimitRow() / 4, start);
1606 start += getLimitRow() / 4 + 1;
1607 createExport(body, builder, rule,
1608 RequestPacket.TRANSFERMODE.RECVTHROUGHMODE.ordinal(),
1609 getLimitRow() / 4, start);
1610 start += getLimitRow() / 4 + 1;
1611 createExport(body, builder, rule,
1612 RequestPacket.TRANSFERMODE.RECVMD5THROUGHMODE.ordinal(),
1613 getLimitRow() / 4, start);
1614 start += getLimitRow() / 4 + 1;
1615 } else if (gmode == -2) {
1616
1617 createExport(body, builder, rule,
1618 RequestPacket.TRANSFERMODE.SENDMODE.ordinal(),
1619 getLimitRow() / 4, start);
1620 start += getLimitRow() / 4 + 1;
1621 createExport(body, builder, rule,
1622 RequestPacket.TRANSFERMODE.SENDMD5MODE.ordinal(),
1623 getLimitRow() / 4, start);
1624 start += getLimitRow() / 4 + 1;
1625 createExport(body, builder, rule,
1626 RequestPacket.TRANSFERMODE.SENDTHROUGHMODE.ordinal(),
1627 getLimitRow() / 4, start);
1628 start += getLimitRow() / 4 + 1;
1629 createExport(body, builder, rule,
1630 RequestPacket.TRANSFERMODE.SENDMD5THROUGHMODE.ordinal(),
1631 getLimitRow() / 4, start);
1632 start += getLimitRow() / 4 + 1;
1633 } else {
1634
1635 createExport(body, builder, rule, -1, getLimitRow(), start);
1636 start += getLimitRow() + 1;
1637 }
1638 }
1639 body = builder.toString();
1640 body1 = REQUEST.Rules.readBodyEnd();
1641 } else if ("Delete".equalsIgnoreCase(parm)) {
1642 final String rule = getTrimValue("rule");
1643 if (ParametersChecker.isEmpty(rule)) {
1644 body0 = body1 = body = "";
1645 body = Messages.getString("HttpSslHandler.29");
1646 head = resetOptionRules(head, "", null, -3);
1647 return head + body0 + body + body1 + end;
1648 }
1649 final DbRule dbrule;
1650 try {
1651 dbrule = new DbRule(rule);
1652 } catch (final WaarpDatabaseException e) {
1653 body0 = body1 = body = "";
1654 body = Messages.getString("HttpSslHandler.30") + e.getMessage()
1655
1656 + B_CENTER_P;
1657 head = resetOptionRules(head, "", null, -3);
1658 return head + body0 + body + body1 + end;
1659 }
1660 try {
1661 dbrule.delete();
1662 } catch (final WaarpDatabaseException e) {
1663 body0 = body1 = body = "";
1664 body = Messages.getString("HttpSslHandler.30") + e.getMessage()
1665
1666 + B_CENTER_P;
1667 head = resetOptionRules(head, "", null, -3);
1668 return head + body0 + body + body1 + end;
1669 }
1670 body0 = body1 = body = "";
1671 body = Messages.getString("HttpSslHandler.31") + rule +
1672 B_CENTER_P;
1673 head = resetOptionRules(head, "", null, -3);
1674 return head + body0 + body + body1 + end;
1675 } else {
1676 head = resetOptionRules(head, "", null, -3);
1677 }
1678 body1 = REQUEST.Rules.readBodyEnd();
1679 } else {
1680 head = resetOptionRules(head, "", null, -3);
1681 }
1682 return head + body0 + body + body1 + end;
1683 }
1684
1685 private String spooled0(final boolean detailed) {
1686
1687 final String spooled = REQUEST.Spooled.readFileUnique(this);
1688 String uri;
1689 if (detailed) {
1690 uri = "SpooledDetailed.html";
1691 } else {
1692 uri = "Spooled.html";
1693 }
1694 final QueryStringDecoder queryStringDecoder =
1695 new QueryStringDecoder(request.uri());
1696 params = queryStringDecoder.parameters();
1697 String name = null;
1698 if (params != null && params.containsKey("name")) {
1699 name = getTrimValue("name");
1700 }
1701 int istatus = 0;
1702 if (params != null && params.containsKey("status")) {
1703 final String status = getTrimValue("status");
1704 try {
1705 istatus = Integer.parseInt(status);
1706 } catch (final NumberFormatException e1) {
1707 istatus = 0;
1708 }
1709 }
1710 if (ParametersChecker.isNotEmpty(name)) {
1711
1712 uri = request.uri();
1713 if (istatus != 0) {
1714 uri += "&status=" + istatus;
1715 }
1716 final StringBuilder builder =
1717 SpooledInformTask.buildSpooledUniqueTable(uri, name);
1718 return spooled.replace("XXXSPOOLEDXXX", builder.toString());
1719 } else {
1720 if (istatus != 0) {
1721 uri += "&status=" + istatus;
1722 }
1723 final StringBuilder builder =
1724 SpooledInformTask.buildSpooledTable(detailed, istatus, uri);
1725 return spooled.replace("XXXSPOOLEDXXX", builder.toString());
1726 }
1727 }
1728
1729
1730
1731
1732
1733
1734 protected void langHandle(final StringBuilder builder) {
1735
1736 WaarpStringUtils.replace(builder, REPLACEMENT.XXXCURLANGENXXX.name(),
1737 "en".equalsIgnoreCase(lang)? CHECKED : "");
1738 WaarpStringUtils.replace(builder, REPLACEMENT.XXXCURLANGFRXXX.name(),
1739 "fr".equalsIgnoreCase(lang)? CHECKED : "");
1740 WaarpStringUtils.replace(builder, REPLACEMENT.XXXCURSYSLANGENXXX.name(),
1741 "en".equalsIgnoreCase(Messages.getSlocale())?
1742 CHECKED : "");
1743 WaarpStringUtils.replace(builder, REPLACEMENT.XXXCURSYSLANGFRXXX.name(),
1744 "fr".equalsIgnoreCase(Messages.getSlocale())?
1745 CHECKED : "");
1746 }
1747
1748 private String systemLimitedSource0() {
1749 final String system = REQUEST.SystemLimited.readFileUnique(this);
1750 if (ParametersChecker.isEmpty(system)) {
1751 return REQUEST.System.readFileUnique(this);
1752 }
1753 return system;
1754 }
1755
1756 final String systemLimited() {
1757 getParams();
1758 DbHostConfiguration config = null;
1759 try {
1760 config = new DbHostConfiguration(Configuration.configuration.getHostId());
1761 } catch (final WaarpDatabaseException e2) {
1762 try {
1763 config =
1764 new DbHostConfiguration(Configuration.configuration.getHostId(), "",
1765 "", "", "");
1766 config.insert();
1767 } catch (final WaarpDatabaseException ignored) {
1768
1769 }
1770 }
1771 if (params == null) {
1772 final String system = systemLimitedSource0();
1773 final StringBuilder builder = new StringBuilder(system);
1774 replaceStringSystem(config, builder);
1775 langHandle(builder);
1776 return builder.toString();
1777 }
1778 String extraInformation = null;
1779 if (params.containsKey(ACTION)) {
1780 final List<String> action = params.get(ACTION);
1781 for (final String act : action) {
1782 if ("Language".equalsIgnoreCase(act)) {
1783 lang = getTrimValue("change");
1784 extraInformation =
1785 Messages.getString(HTTP_SSL_HANDLER_LANG_IS) + "Web: " + lang +
1786 " OpenR66: "
1787 + Messages.getSlocale();
1788 } else if ("Disconnect".equalsIgnoreCase(act)) {
1789 String logon = logon();
1790 logon = logon.replaceAll(REPLACEMENT.XXXERRORMESGXXX.toString(),
1791 Messages.getString(
1792 "HttpSslHandler.DisActive"));
1793 newSession = true;
1794 clearSession();
1795 forceClose = true;
1796 return logon;
1797 }
1798 }
1799 }
1800 final String system = systemLimitedSource0();
1801 final StringBuilder builder = new StringBuilder(system);
1802 replaceStringSystem(config, builder);
1803 langHandle(builder);
1804 if (extraInformation != null) {
1805 builder.append(extraInformation);
1806 }
1807 return builder.toString();
1808 }
1809
1810
1811
1812
1813
1814 final void replaceStringSystem(final DbHostConfiguration config,
1815 final StringBuilder builder) {
1816 if (config != null) {
1817 WaarpStringUtils.replace(builder, REPLACEMENT.XXXXBUSINESSXXX.toString(),
1818 config.getBusiness());
1819 WaarpStringUtils.replace(builder, REPLACEMENT.XXXXROLESXXX.toString(),
1820 config.getRoles());
1821 WaarpStringUtils.replace(builder, REPLACEMENT.XXXXALIASESXXX.toString(),
1822 config.getAliases());
1823 WaarpStringUtils.replace(builder, REPLACEMENT.XXXXOTHERXXX.toString(),
1824 config.getOthers());
1825 }
1826 WaarpStringUtils.replace(builder,
1827 REPLACEMENT.XXXXSESSIONLIMITWXXX.toString(),
1828 Long.toString(
1829 Configuration.configuration.getServerChannelWriteLimit()));
1830 WaarpStringUtils.replace(builder,
1831 REPLACEMENT.XXXXSESSIONLIMITRXXX.toString(),
1832 Long.toString(
1833 Configuration.configuration.getServerChannelReadLimit()));
1834 WaarpStringUtils.replace(builder, REPLACEMENT.XXXXDELATRAFFICXXX.toString(),
1835 Long.toString(
1836 Configuration.configuration.getDelayLimit()));
1837 WaarpStringUtils.replace(builder, REPLACEMENT.XXXXDELAYCOMMDXXX.toString(),
1838 Long.toString(
1839 Configuration.configuration.getDelayCommander()));
1840 WaarpStringUtils.replace(builder, REPLACEMENT.XXXXDELAYRETRYXXX.toString(),
1841 Long.toString(
1842 Configuration.configuration.getDelayRetry()));
1843 WaarpStringUtils.replace(builder,
1844 REPLACEMENT.XXXXCHANNELLIMITWXXX.toString(),
1845 Long.toString(
1846 Configuration.configuration.getServerGlobalWriteLimit()));
1847 WaarpStringUtils.replace(builder,
1848 REPLACEMENT.XXXXCHANNELLIMITRXXX.toString(),
1849 Long.toString(
1850 Configuration.configuration.getServerGlobalReadLimit()));
1851 WaarpStringUtils.replace(builder, "XXXBLOCKXXX",
1852 Configuration.configuration.isShutdown()? CHECKED :
1853 "");
1854 switch (WaarpLoggerFactory.getLogLevel()) {
1855 case DEBUG:
1856 WaarpStringUtils.replace(builder, XXXLEVEL1XXX, CHECKED);
1857 WaarpStringUtils.replace(builder, XXXLEVEL2XXX, "");
1858 WaarpStringUtils.replace(builder, XXXLEVEL3XXX, "");
1859 WaarpStringUtils.replace(builder, XXXLEVEL4XXX, "");
1860 break;
1861 case INFO:
1862 WaarpStringUtils.replace(builder, XXXLEVEL1XXX, "");
1863 WaarpStringUtils.replace(builder, XXXLEVEL2XXX, CHECKED);
1864 WaarpStringUtils.replace(builder, XXXLEVEL3XXX, "");
1865 WaarpStringUtils.replace(builder, XXXLEVEL4XXX, "");
1866 break;
1867 case WARN:
1868 WaarpStringUtils.replace(builder, XXXLEVEL1XXX, "");
1869 WaarpStringUtils.replace(builder, XXXLEVEL2XXX, "");
1870 WaarpStringUtils.replace(builder, XXXLEVEL3XXX, CHECKED);
1871 WaarpStringUtils.replace(builder, XXXLEVEL4XXX, "");
1872 break;
1873 case ERROR:
1874 WaarpStringUtils.replace(builder, XXXLEVEL1XXX, "");
1875 WaarpStringUtils.replace(builder, XXXLEVEL2XXX, "");
1876 WaarpStringUtils.replace(builder, XXXLEVEL3XXX, "");
1877 WaarpStringUtils.replace(builder, XXXLEVEL4XXX, CHECKED);
1878 break;
1879 default:
1880 WaarpStringUtils.replace(builder, XXXLEVEL1XXX, "");
1881 WaarpStringUtils.replace(builder, XXXLEVEL2XXX, "");
1882 WaarpStringUtils.replace(builder, XXXLEVEL3XXX, "");
1883 WaarpStringUtils.replace(builder, XXXLEVEL4XXX, "");
1884 break;
1885
1886 }
1887 }
1888
1889 final String logout() {
1890 String logon = logon();
1891 logon = logon.replaceAll(REPLACEMENT.XXXERRORMESGXXX.toString(),
1892 Messages.getString("HttpSslHandler.Disconnected"));
1893 newSession = true;
1894 clearSession();
1895 forceClose = true;
1896 return logon;
1897 }
1898
1899 private String system0() {
1900 getParams();
1901 DbHostConfiguration config = null;
1902 try {
1903 config = new DbHostConfiguration(Configuration.configuration.getHostId());
1904 } catch (final WaarpDatabaseException e2) {
1905 try {
1906 config =
1907 new DbHostConfiguration(Configuration.configuration.getHostId(), "",
1908 "", "", "");
1909 config.insert();
1910 } catch (final WaarpDatabaseException ignored) {
1911
1912 }
1913 }
1914 if (params == null) {
1915 final String system = REQUEST.System.readFileUnique(this);
1916 final StringBuilder builder = new StringBuilder(system);
1917 replaceStringSystem(config, builder);
1918 langHandle(builder);
1919 return builder.toString();
1920 }
1921 String extraInformation = null;
1922 if (params.containsKey(ACTION)) {
1923 final List<String> action = params.get(ACTION);
1924 for (final String act : action) {
1925 if ("Language".equalsIgnoreCase(act)) {
1926 lang = getTrimValue("change");
1927 final String sys = getTrimValue("changesys");
1928 Messages.init(new Locale(sys));
1929 extraInformation =
1930 Messages.getString(HTTP_SSL_HANDLER_LANG_IS) + "Web: " + lang +
1931 " OpenR66: "
1932 + Messages.getSlocale();
1933 } else if ("Level".equalsIgnoreCase(act)) {
1934 final String loglevel = getTrimValue("loglevel");
1935 WaarpLogLevel level = WaarpLogLevel.WARN;
1936 if ("debug".equalsIgnoreCase(loglevel)) {
1937 level = WaarpLogLevel.DEBUG;
1938 } else if ("info".equalsIgnoreCase(loglevel)) {
1939 level = WaarpLogLevel.INFO;
1940 } else if ("warn".equalsIgnoreCase(loglevel)) {
1941 level = WaarpLogLevel.WARN;
1942 } else if (ERROR2.equalsIgnoreCase(loglevel)) {
1943 level = WaarpLogLevel.ERROR;
1944 }
1945 WaarpLoggerFactory.setLogLevel(level);
1946 extraInformation = Messages.getString(HTTP_SSL_HANDLER_LANG_IS) +
1947 level.name();
1948 } else if ("ExportConfig".equalsIgnoreCase(act)) {
1949 final String directory =
1950 Configuration.configuration.getBaseDirectory() +
1951 DirInterface.SEPARATOR +
1952 Configuration.configuration.getArchivePath();
1953 extraInformation =
1954 Messages.getString("HttpSslHandler.ExportDir") + directory +
1955 "<br>";
1956 final String[] filenames =
1957 ServerActions.staticConfigExport(directory, true, true, true,
1958 true, true);
1959
1960 if (filenames[0] != null) {
1961 extraInformation +=
1962 Messages.getString("HttpSslHandler.33");
1963 }
1964 if (filenames[1] != null) {
1965 extraInformation +=
1966 Messages.getString("HttpSslHandler.32");
1967 }
1968 if (filenames[2] != null) {
1969 extraInformation +=
1970 Messages.getString("HttpSslHandler.44");
1971 }
1972 if (filenames[3] != null) {
1973 extraInformation +=
1974 Messages.getString("HttpSslHandler.45");
1975 }
1976 if (filenames[4] != null) {
1977 extraInformation +=
1978 Messages.getString("HttpSslHandler.46");
1979 }
1980 } else if ("Disconnect".equalsIgnoreCase(act)) {
1981 return logout();
1982 } else if ("Block".equalsIgnoreCase(act)) {
1983 final boolean block = params.containsKey("blocking");
1984 if (block) {
1985 extraInformation =
1986 Messages.getString("HttpSslHandler.34");
1987 } else {
1988 extraInformation =
1989 Messages.getString("HttpSslHandler.35");
1990 }
1991 Configuration.configuration.setShutdown(block);
1992 } else if ("Shutdown".equalsIgnoreCase(act)) {
1993 final String error;
1994 if (Configuration.configuration.getShutdownConfiguration().serviceFuture !=
1995 null) {
1996 error =
1997 error(Messages.getString("HttpSslHandler.38"));
1998 } else {
1999 error =
2000 error(Messages.getString("HttpSslHandler.37"));
2001 }
2002 WaarpShutdownHook.setRestart(false);
2003 newSession = true;
2004 clearSession();
2005 forceClose = true;
2006 shutdown = true;
2007 return error;
2008 } else if ("Restart".equalsIgnoreCase(act)) {
2009 String error;
2010 if (Configuration.configuration.getShutdownConfiguration().serviceFuture !=
2011 null) {
2012 error =
2013 error(Messages.getString("HttpSslHandler.38"));
2014 } else {
2015 error = error(Messages.getString("HttpSslHandler.39")
2016
2017 + Configuration.configuration.getTimeoutCon() * 2 /
2018 1000 + Messages.getString(
2019 "HttpSslHandler.40"));
2020 }
2021 error = error.replace("XXXRELOADHTTPXXX",
2022 "HTTP-EQUIV=\"refresh\" CONTENT=\"" +
2023 Configuration.configuration.getTimeoutCon() *
2024 2 / 1000 + '"');
2025 WaarpShutdownHook.setRestart(true);
2026 newSession = true;
2027 clearSession();
2028 forceClose = true;
2029 shutdown = true;
2030 return error;
2031 } else if ("Validate".equalsIgnoreCase(act)) {
2032 final String bsessionr = getTrimValue("BSESSR");
2033 long lsessionr =
2034 Configuration.configuration.getServerChannelReadLimit();
2035 long lglobalr;
2036 long lsessionw;
2037 long lglobalw;
2038 long delay;
2039 try {
2040 if (bsessionr != null) {
2041 lsessionr = (Long.parseLong(bsessionr) / 10) * 10;
2042 }
2043 final String bglobalr = getTrimValue("BGLOBR");
2044 lglobalr = Configuration.configuration.getServerGlobalReadLimit();
2045 if (bglobalr != null) {
2046 lglobalr = (Long.parseLong(bglobalr) / 10) * 10;
2047 }
2048 final String bsessionw = getTrimValue("BSESSW");
2049 lsessionw =
2050 Configuration.configuration.getServerChannelWriteLimit();
2051 if (bsessionw != null) {
2052 lsessionw = (Long.parseLong(bsessionw) / 10) * 10;
2053 }
2054 final String bglobalw = getTrimValue("BGLOBW");
2055 lglobalw = Configuration.configuration.getServerGlobalWriteLimit();
2056 if (bglobalw != null) {
2057 lglobalw = (Long.parseLong(bglobalw) / 10) * 10;
2058 }
2059 final String dtra = getTrimValue("DTRA");
2060 delay = Configuration.configuration.getDelayLimit();
2061 if (dtra != null) {
2062 delay = (Long.parseLong(dtra) / 10) * 10;
2063 if (delay < 100) {
2064 delay = 100;
2065 }
2066 }
2067 Configuration.configuration.changeNetworkLimit(lglobalw, lglobalr,
2068 lsessionw, lsessionr,
2069 delay);
2070 final String dcomm = getTrimValue("DCOM");
2071 if (dcomm != null) {
2072 Configuration.configuration.setDelayCommander(
2073 Long.parseLong(dcomm));
2074 if (Configuration.configuration.getDelayCommander() <= 100) {
2075 Configuration.configuration.setDelayCommander(100);
2076 }
2077 Configuration.configuration.reloadCommanderDelay();
2078 }
2079 final String dret = getTrimValue("DRET");
2080 if (dret != null) {
2081 Configuration.configuration.setDelayRetry(Long.parseLong(dret));
2082 if (Configuration.configuration.getDelayRetry() <= 1000) {
2083 Configuration.configuration.setDelayRetry(1000);
2084 }
2085 }
2086 extraInformation =
2087 Messages.getString("HttpSslHandler.41");
2088 } catch (final NumberFormatException e) {
2089 extraInformation =
2090 Messages.getString("HttpSslHandler.42");
2091 }
2092 } else if ("HostConfig".equalsIgnoreCase(act)) {
2093 config.setBusiness(getTrimValue("BUSINESS"));
2094 config.setRoles(getTrimValue("ROLES"));
2095 config.setAliases(getTrimValue("ALIASES"));
2096 config.setOthers(getTrimValue("OTHER"));
2097 try {
2098 config.update();
2099 extraInformation =
2100 Messages.getString("HttpSslHandler.41");
2101 } catch (final WaarpDatabaseException e) {
2102 extraInformation =
2103 Messages.getString("HttpSslHandler.43");
2104 }
2105 }
2106 }
2107 }
2108 final String system = REQUEST.System.readFileUnique(this);
2109 final StringBuilder builder = new StringBuilder(system);
2110 replaceStringSystem(config, builder);
2111 langHandle(builder);
2112 if (extraInformation != null) {
2113 builder.append(extraInformation);
2114 }
2115 return builder.toString();
2116 }
2117
2118 private void getParams() {
2119 if (request.method() == HttpMethod.GET) {
2120 params = null;
2121 } else if (request.method() == HttpMethod.POST) {
2122 final ByteBuf content = request.content();
2123 if (content.isReadable()) {
2124 final String param = content.toString(WaarpStringUtils.UTF8);
2125 final QueryStringDecoder queryStringDecoder2 =
2126 new QueryStringDecoder("/?" + param);
2127 params = queryStringDecoder2.parameters();
2128 boolean invalidEntry = false;
2129 for (final Entry<String, List<String>> paramCheck : params.entrySet()) {
2130 try {
2131 ParametersChecker.checkSanityString(paramCheck.getValue().toArray(
2132 ParametersChecker.ZERO_ARRAY_STRING));
2133 } catch (final InvalidArgumentException e) {
2134 logger.error(
2135 "Arguments incompatible with Security: " + paramCheck.getKey() +
2136 ": {}", e.getMessage());
2137 invalidEntry = true;
2138 }
2139 }
2140 if (invalidEntry) {
2141 for (final Entry<String, List<String>> paramCheck : params.entrySet()) {
2142 paramCheck.getValue().clear();
2143 }
2144 params.clear();
2145 params = null;
2146 logger.error("No parameter validated since security issue found");
2147 return;
2148 }
2149 if (params.containsKey(sLIMITROW)) {
2150 final String snb = getTrimValue(sLIMITROW);
2151 if (snb != null) {
2152 try {
2153 final int old = getLimitRow();
2154 setLimitRow(Integer.parseInt(snb));
2155 if (getLimitRow() < 5) {
2156 setLimitRow(old);
2157 }
2158 } catch (final Exception ignored) {
2159
2160 }
2161 }
2162 }
2163 } else {
2164 params = null;
2165 }
2166 }
2167 }
2168
2169 protected void clearSession() {
2170 if (admin != null) {
2171 final R66Session lsession = sessions.remove(admin.value());
2172 admin = null;
2173 if (lsession != null) {
2174 lsession.setStatus(75);
2175 lsession.clear();
2176 }
2177 }
2178 }
2179
2180 private void checkAuthent(final ChannelHandlerContext ctx) {
2181 newSession = true;
2182 if (request.method() == HttpMethod.GET) {
2183 String logon = logon();
2184 logon = logon.replaceAll(REPLACEMENT.XXXERRORMESGXXX.toString(), "");
2185 responseContent.append(logon);
2186 clearSession();
2187 writeResponse(ctx);
2188 return;
2189 } else if (request.method() == HttpMethod.POST) {
2190 getParams();
2191 if (params == null) {
2192 String logon = logon();
2193 logon = logon.replaceAll(REPLACEMENT.XXXERRORMESGXXX.toString(),
2194 Messages.getString(
2195 "HttpSslHandler.EmptyLogin"));
2196 responseContent.append(logon);
2197 clearSession();
2198 writeResponse(ctx);
2199 return;
2200 }
2201 }
2202 boolean getMenu = false;
2203 if (params != null && params.containsKey("Logon")) {
2204 String name = null;
2205 String password = null;
2206 List<String> values;
2207 if (!params.isEmpty()) {
2208
2209 if (params.containsKey("name")) {
2210 values = params.get("name");
2211 if (values != null) {
2212 name = values.get(0);
2213 if (ParametersChecker.isEmpty(name)) {
2214 getMenu = true;
2215 }
2216 }
2217 } else {
2218 getMenu = true;
2219 }
2220
2221 if (!getMenu && params.containsKey("passwd")) {
2222 values = params.get("passwd");
2223 if (values != null) {
2224 password = values.get(0);
2225 getMenu = ParametersChecker.isEmpty(password);
2226 } else {
2227 getMenu = true;
2228 }
2229 } else {
2230 getMenu = true;
2231 }
2232 } else {
2233 getMenu = true;
2234 }
2235 if (!getMenu && name != null) {
2236 logger.debug("Name? {} Passwd? {}",
2237 name.equals(Configuration.configuration.getAdminName()),
2238 Arrays.equals(password.getBytes(WaarpStringUtils.UTF8),
2239 Configuration.configuration.getServerAdminKey()));
2240 if (name.equals(Configuration.configuration.getAdminName()) &&
2241 Arrays.equals(password.getBytes(WaarpStringUtils.UTF8),
2242 Configuration.configuration.getServerAdminKey())) {
2243 authentHttp.getAuth().specialNoSessionAuth(true,
2244 Configuration.configuration.getHostId());
2245 authentHttp.setStatus(70);
2246 } else {
2247 try {
2248 authentHttp.getAuth().connectionHttps(name,
2249 FilesystemBasedDigest.passwdCrypt(
2250 password.getBytes(
2251 WaarpStringUtils.UTF8)));
2252 } catch (final Reply530Exception e1) {
2253 getMenu = true;
2254 } catch (final Reply421Exception e1) {
2255 getMenu = true;
2256 }
2257 }
2258 if (!authentHttp.isAuthenticated()) {
2259 authentHttp.setStatus(71);
2260 logger.info("Still not authenticated: {}", authentHttp);
2261 getMenu = true;
2262 }
2263 logger.debug("Identified: {}:{}", authentHttp.getAuth().isIdentified(),
2264 authentHttp.isAuthenticated());
2265 }
2266 } else {
2267 getMenu = true;
2268 }
2269 if (getMenu) {
2270 String logon = logon();
2271 logon = logon.replaceAll(REPLACEMENT.XXXERRORMESGXXX.toString(),
2272 Messages.getString("HttpSslHandler.BadLogin"));
2273 responseContent.append(logon);
2274 clearSession();
2275 } else {
2276 final String index = index();
2277 responseContent.append(index);
2278 clearSession();
2279 admin = new DefaultCookie(
2280 R66SESSION + Configuration.configuration.getHostId(),
2281 Configuration.configuration.getHostId() +
2282 Long.toHexString(RANDOM.nextLong()));
2283 sessions.put(admin.value(), authentHttp);
2284 authentHttp.setStatus(72);
2285 logger.debug("CreateSession: {}:{}", uriRequest, admin);
2286 }
2287 writeResponse(ctx);
2288 }
2289
2290 @Override
2291 protected void channelRead0(final ChannelHandlerContext ctx,
2292 final FullHttpRequest msg) {
2293 final FullHttpRequest httpRequest = this.request = msg;
2294 final QueryStringDecoder queryStringDecoder =
2295 new QueryStringDecoder(httpRequest.uri());
2296 uriRequest = queryStringDecoder.path();
2297 logger.debug("Msg: {}", uriRequest);
2298 if (uriRequest.contains("gre/") || uriRequest.contains("img/") ||
2299 uriRequest.contains("res/") || uriRequest.contains("favicon.ico")) {
2300 HttpWriteCacheEnable.writeFile(httpRequest, ctx,
2301 Configuration.configuration.getHttpBasePath() +
2302 uriRequest, R66SESSION +
2303 Configuration.configuration.getHostId());
2304 return;
2305 }
2306 checkSession(ctx.channel());
2307 try {
2308 if (!authentHttp.isAuthenticated()) {
2309 logger.debug("Not Authent: {}:{}", uriRequest, authentHttp);
2310 checkAuthent(ctx);
2311 return;
2312 }
2313 String find = uriRequest;
2314 if (uriRequest.charAt(0) == '/') {
2315 find = uriRequest.substring(1);
2316 }
2317 REQUEST req = REQUEST.index;
2318 if (find.length() != 0) {
2319 find = find.substring(0, find.indexOf('.'));
2320 try {
2321 req = REQUEST.valueOf(find);
2322 } catch (final IllegalArgumentException e1) {
2323 req = REQUEST.index;
2324 logger.info("NotFound: {}:{}", find, uriRequest);
2325 }
2326 }
2327 switch (req) {
2328 case CancelRestart:
2329 if (authentHttp.getAuth().isValidRole(ROLE.TRANSFER)) {
2330 responseContent.append(cancelRestart0());
2331 } else {
2332 responseContent.append(unallowed(
2333 Messages.getString("HttpSslHandler.CancelRestartUnallowed")));
2334 }
2335 break;
2336 case Export:
2337 if (authentHttp.getAuth().isValidRole(ROLE.SYSTEM)) {
2338 responseContent.append(export0());
2339 } else {
2340 responseContent.append(unallowed(
2341 Messages.getString("HttpSslHandler.ExportUnallowed")));
2342 }
2343 break;
2344 case Hosts:
2345 if (authentHttp.getAuth().isValidRole(ROLE.HOST)) {
2346 responseContent.append(hosts0());
2347 } else {
2348 responseContent.append(
2349 unallowed(Messages.getString("HttpSslHandler.HostUnallowed")));
2350 }
2351 break;
2352 case Listing:
2353 responseContent.append(listing0());
2354 break;
2355 case Logout:
2356 responseContent.append(logout());
2357 break;
2358 case Rules:
2359 if (authentHttp.getAuth().isValidRole(ROLE.RULE)) {
2360 responseContent.append(rules0());
2361 } else {
2362 responseContent.append(
2363 unallowed(Messages.getString("HttpSslHandler.RulesUnallowed")));
2364 }
2365 break;
2366 case System:
2367 if (authentHttp.getAuth().isValidRole(ROLE.SYSTEM)) {
2368 responseContent.append(system0());
2369 } else {
2370 responseContent.append(systemLimited());
2371 }
2372 break;
2373 case Transfers:
2374 responseContent.append(transfers());
2375 break;
2376 case Spooled:
2377 responseContent.append(spooled0(false));
2378 break;
2379 case SpooledDetailed:
2380 responseContent.append(spooled0(true));
2381 break;
2382 default:
2383 responseContent.append(index());
2384 break;
2385 }
2386 writeResponse(ctx);
2387 } finally {
2388 closeConnection();
2389 }
2390 }
2391
2392 protected final void checkSession(final Channel channel) {
2393 final String cookieString = request.headers().get(HttpHeaderNames.COOKIE);
2394 if (cookieString != null) {
2395 final Set<Cookie> cookies = ServerCookieDecoder.LAX.decode(cookieString);
2396 if (!cookies.isEmpty()) {
2397 for (final Cookie elt : cookies) {
2398 if (elt.name().equalsIgnoreCase(
2399 R66SESSION + Configuration.configuration.getHostId())) {
2400 logger.debug("Found session: {}", elt);
2401 admin = elt;
2402 final R66Session session = sessions.get(admin.value());
2403 if (session != null) {
2404 authentHttp = session;
2405 authentHttp.setStatus(73);
2406 } else {
2407 admin = null;
2408 }
2409 } else if (elt.name().equalsIgnoreCase(I18NEXT)) {
2410 logger.debug("Found i18next: {}", elt);
2411 lang = elt.value();
2412 }
2413 }
2414 }
2415 }
2416 try {
2417 dbSession = new DbSession(DbConstantR66.admin, false);
2418 DbAdmin.incHttpSession();
2419 } catch (final WaarpDatabaseNoConnectionException e1) {
2420
2421 logger.warn("Use default database connection");
2422 dbSession = DbConstantR66.admin.getSession();
2423 }
2424 if (admin == null) {
2425 logger.debug("NoSession: {}:{}", uriRequest, admin);
2426 }
2427 }
2428
2429 protected final void closeConnection() {
2430 if (dbSession != null && dbSession != DbConstantR66.admin.getSession()) {
2431 DbAdmin.decHttpSession();
2432 dbSession.disconnect();
2433 }
2434 dbSession = null;
2435 }
2436
2437 private void handleCookies(final HttpResponse response) {
2438 final String cookieString = request.headers().get(HttpHeaderNames.COOKIE);
2439 boolean i18nextFound = false;
2440 if (cookieString != null) {
2441 final Set<Cookie> cookies = ServerCookieDecoder.LAX.decode(cookieString);
2442 if (!cookies.isEmpty()) {
2443
2444 boolean findSession = false;
2445 for (final Cookie cookie : cookies) {
2446 if (cookie.name().equalsIgnoreCase(
2447 R66SESSION + Configuration.configuration.getHostId())) {
2448 if (newSession) {
2449 findSession = false;
2450 } else {
2451 findSession = true;
2452 response.headers().add(HttpHeaderNames.SET_COOKIE,
2453 ServerCookieEncoder.LAX.encode(cookie));
2454 }
2455 } else if (cookie.name().equalsIgnoreCase(I18NEXT)) {
2456 i18nextFound = true;
2457 cookie.setValue(lang);
2458 response.headers().add(HttpHeaderNames.SET_COOKIE,
2459 ServerCookieEncoder.LAX.encode(cookie));
2460 } else {
2461 response.headers().add(HttpHeaderNames.SET_COOKIE,
2462 ServerCookieEncoder.LAX.encode(cookie));
2463 }
2464 }
2465 if (!i18nextFound) {
2466 final Cookie cookie = new DefaultCookie(I18NEXT, lang);
2467 response.headers().add(HttpHeaderNames.SET_COOKIE,
2468 ServerCookieEncoder.LAX.encode(cookie));
2469 }
2470 newSession = false;
2471 if (!findSession && admin != null) {
2472 response.headers().add(HttpHeaderNames.SET_COOKIE,
2473 ServerCookieEncoder.LAX.encode(admin));
2474 logger.debug("AddSession: {}:{}", uriRequest, admin);
2475 }
2476 }
2477 } else {
2478 final Cookie cookie = new DefaultCookie(I18NEXT, lang);
2479 response.headers().add(HttpHeaderNames.SET_COOKIE,
2480 ServerCookieEncoder.LAX.encode(cookie));
2481 if (admin != null) {
2482 logger.debug("AddSession: {}:{}", uriRequest, admin);
2483 response.headers().add(HttpHeaderNames.SET_COOKIE,
2484 ServerCookieEncoder.LAX.encode(admin));
2485 }
2486 }
2487 }
2488
2489
2490
2491
2492
2493
2494 protected final void writeResponse(final ChannelHandlerContext ctx) {
2495
2496 final ByteBuf buf = Unpooled.copiedBuffer(responseContent.toString(),
2497 WaarpStringUtils.UTF8);
2498 responseContent.setLength(0);
2499
2500
2501 final boolean keepAlive = HttpUtil.isKeepAlive(request);
2502 final boolean close = HttpHeaderValues.CLOSE.contentEqualsIgnoreCase(
2503 request.headers().get(HttpHeaderNames.CONNECTION)) || !keepAlive ||
2504 forceClose;
2505
2506
2507 final FullHttpResponse response =
2508 new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK,
2509 buf);
2510 response.headers().add(HttpHeaderNames.CONTENT_LENGTH,
2511 response.content().readableBytes());
2512 response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/html");
2513 if (keepAlive) {
2514 response.headers()
2515 .set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE);
2516 }
2517 if (!close) {
2518
2519
2520 response.headers().set(HttpHeaderNames.CONTENT_LENGTH,
2521 String.valueOf(buf.readableBytes()));
2522 }
2523
2524 handleCookies(response);
2525
2526
2527 final ChannelFuture future = ctx.writeAndFlush(response);
2528
2529 if (close) {
2530 future.addListener(WaarpSslUtility.SSLCLOSE);
2531 }
2532 if (shutdown) {
2533 ChannelUtils.startShutdown();
2534 }
2535 }
2536
2537
2538
2539
2540
2541
2542
2543 final void sendError(final ChannelHandlerContext ctx,
2544 final HttpResponseStatus status) {
2545 responseContent.setLength(0);
2546 responseContent.append(error(status.toString()));
2547 final FullHttpResponse response =
2548 new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, status,
2549 Unpooled.copiedBuffer(
2550 responseContent.toString(),
2551 WaarpStringUtils.UTF8));
2552 response.headers().add(HttpHeaderNames.CONTENT_LENGTH,
2553 response.content().readableBytes());
2554 response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/html");
2555 responseContent.setLength(0);
2556 clearSession();
2557
2558 ctx.writeAndFlush(response).addListener(WaarpSslUtility.SSLCLOSE);
2559 }
2560
2561 @Override
2562 public void exceptionCaught(final ChannelHandlerContext ctx,
2563 final Throwable cause) {
2564 final OpenR66Exception exception =
2565 OpenR66ExceptionTrappedFactory.getExceptionFromTrappedException(
2566 ctx.channel(), cause);
2567 if (exception != null) {
2568 if (!(exception instanceof OpenR66ProtocolBusinessNoWriteBackException)) {
2569 if (cause instanceof IOException) {
2570
2571 return;
2572 }
2573 logger.warn("Exception in HttpSslHandler {}", exception.getMessage());
2574 }
2575 if (ctx.channel().isActive()) {
2576 sendError(ctx, HttpResponseStatus.BAD_REQUEST);
2577 }
2578 } else {
2579
2580 }
2581 }
2582
2583 @Override
2584 public void channelActive(final ChannelHandlerContext ctx) throws Exception {
2585 final Channel channel = ctx.channel();
2586 Configuration.configuration.getHttpChannelGroup().add(channel);
2587 super.channelActive(ctx);
2588 }
2589
2590
2591
2592
2593 public final int getLimitRow() {
2594 return limitRow;
2595 }
2596
2597
2598
2599
2600 final void setLimitRow(final int lIMITROW) {
2601 limitRow = lIMITROW;
2602 }
2603
2604
2605
2606
2607 public final int getRefresh() {
2608 return refresh;
2609 }
2610
2611
2612
2613
2614 final void setRefresh(final int rEFRESH) {
2615 refresh = rEFRESH;
2616 }
2617
2618 }